怎样在ARM下进行高效的C编程？

taobao322

# b' o8 w$ x. g1 D  `$ v

, J# a4 G/ `' t- V通过一定的风格来编写C程序，可以帮助C编译器生成执行速度更快的ARM代码。下面就是一些与性能相关的关键点：

        1.对局部变量、函数参数和返回值要使用signed和unsigned int类型。这样可以避免类型转换，而且可高效地使用ARM的32位数据操作指令。       2.最高效的循环体形式是减计数到零（counts down to zero）的do-while循环。       3.展开重要的循环来减少循环的开销。       4.不要依赖编译器来优化掉重复的存储器访问。指针别名会阻止编译器的这种优化。       5.尽可能把函数参数的个数限制在4个以内。如果函数参数都存放在寄存器内，那么函数调用就会快得多。       6.按元素尺寸从小到大排列的方法来安排结构体，特别是在thumb模式下编译。       7.不要使用位域，可以用掩码和逻辑操作来替代。       8.避免除法，可以用倒数的乘法来替代。       9.避免边界不对齐的数据。如果数据有可能边界不对齐，那么就要使用char *指针类型来访问。       10.在C编译器中使用内嵌汇编可以利用到C编译器本来不支持的指令或优化。      一、 数据类型使用上的优化:
& @7 k- z& H3 t5 j# g
1.局部变量6 v/ F4 m6 u% l# e4 \1 |
一个char类型的数据比int类型的数据占用更小的寄存器空间或者更小的ARM堆栈空间。这两种设想对于ARM来说，都是错误的。所有的ARM寄存器都是32位的，所有的堆栈入口至少是32位的。当我们执行i++，要利用当i=255后，i++=0这个条件时，可以把它定义为char类型。      r$ X. Q! q& v! ~0 y. J' K
9 G$ S% c/ t0 k4 w8 l+ H: j  2.函数参数2 `1 y& ^  ]2 j$ n7 W( X5 O: D
5 O( R! c8 z7 e* h尽管宽和窄的函数调用规则各有其优点，但char或short类型的函数参数和返回值都会产生额外的开销，导致性能的下降，并增加了代码尺寸。所以，即使是传输一个8位的数据，函数参数和返回值使用int类型也会更有效。          
) ]) m# u# T/ s4 M, P* H! Z  总结:           + U! I. J* k/ L0 Y
' t" ^* A4 T5 [   1）对于存放在寄存器中的局部变量，除了8位或16位的算术模运算外，尽量不要使用char和short类型，而要使用有符号或无符号int类型。除法运算时使用无符号数执行速度更快。            5 r& o) Q' V7 ~: N7 Z2 d
  2）对于存放在主存储器中的数组和全局变量，在满足数据大小的前提下，应尽可能使用小尺寸的数据类型，这样可以节省存储空间。ARMv4体系结构可以有效地装载和存储所有宽度的数据，并可以使用递增数组指针来有效地访问数组。对于short类型数组，要避免使用数组基地址的偏移量，因为LDRH指令不支持偏移寻址。            0 ]& Z- Q8 _) K" M! g, {9 Y
  3）通过读取数组或全局变量并赋给不同类型的局部变量时，或者把局部变量写入不同类型的数组或者全局变量时，要进行显式数据类型转换。这种转换使编译器可以明确、快速地处理，把存储器中数据宽度比较窄的数据类型扩展，并赋给寄存器中较宽的类型。         
' I  d, g6 t7 s# x     4）由于隐式或者显式的数据类型转换通常会有额外的指令周期开销，所以在表达式中应尽量避免使用。Load和store指令一般不会产生额外的转换开销，因为load和store指令是自动完成数据类型转换的。           2 D! i! g' Y0 d4 _' C1 g4 v
   5）对于函数参数和返回值应尽量避免使用char和short类型。即使参数范围比较小，也应该使用int类型，以防止编译器做不必要的类型转换。$ K1 Z& K) i* p2 B$ m# c% q
  M" g! G8 C# e' m6 p! @7 f5 |
' e5 ^4 [/ s/ D二、C循环结构- x1 n9 y) U2 N2 G/ R9 p- X' l7 p
在ARM上，一个循环其实只要2条指令就足够了：
6 {) Y' P! y) }- c& Y4 F

• 一条减法指令，进行循环减法计数，同时设置结果的条件标志；
• 一条条件分支指令。7 ]3 Q; A* w+ M/ a3 W, x
  
  

/ q2 g3 k6 ]2 K
, X$ c. X4 b' g6 r& g这里的关键是，循环的终止条件应为减计数到零，而不是计数增加到某个特定的限制值。由于减计数结构已存储在条件标志里，与零比较的指令就可以省略了。由于不用i作为数组的下标索引，采用减计数就没有任何问题了。
/ ~, Z. ]2 o+ E3 J' m7 T: z% I2 x
* o' S* Y% |" u" V( I总而言之，无论对于有符号的循环计数值，都应使用i！=0作为循环的结束条件。对有符号数i，这比使用条件i>0少了一条指令。" z, C; R/ ^" ^! C" M' p, R
0 N: n, X! z1 B4 i' `6 ?) c0 |
总结：4 p5 E0 W# u0 W- ?- X9 d: w
* M5 S3 ?6 B/ j1） 使用减计数到零的循环结构，这样编译器就不需要分配一个寄存器来保存循环终止值，而且与0比较的指令也可以省略。
  s) M: L: B1 h' |4 I' L/ G$ F9 w2） 使用无符号的循环计数值，循环继续的条件为i!=0而不是i>0，这样可以保证循环开销只有两条指令。+ Q( a- q* z) O3 D
3） 如果事先知道循环体至少会执行一次，那么使用do-while循环要比for循环要好，这样可以使编译器省去检查循环计数值是否为零的步骤。
4） 展开重要的循环体可降低循环开销，但不要过度展开，如果循环的开销对整个程序来说占的比例很小，那么循环展开反而会增加代码量并降低cache的性能。
5） 尽量使数组的大小是4或8的倍数，这样可以容易的以2，4，8次等多种选择展开循环，而不需要担心剩余数组元素的问题。
& [3 ^8 I9 L! _: I" n
8 S5 _- K1 J( n+ Z% [" T6 A三、寄存器分配
高效的寄存器分配:应该尽量限制函数内部循环所用局部变量的数目，最多不超过12个，这样，编译器就可以把这些变量都分配给ARM寄存器。
# |7 r5 b2 I* \& r4 i  y
四、函数调用
7 z% a* N) m+ Q! x3 \4 \
9 k7 I& P, ~: M. ~$ Y# Q4寄存器规则:带有4个或者更少参数的函数，要比多于4个参数的函数执行效率高得多。对带有少于4个参数的函数来说，编译器可以用寄存器传递所有的参数；而对于多于4个参数的函数，函数调用者和被调用者必须通过访问堆栈来传递一些参数。
$ J/ q, X4 o1 m0 J8 u  `  u7 x
% j9 S6 ?$ s8 z如果函数体积很小，只用到很少的寄存器，那么还有一些其他的方法来减少函数调用的开销。可以把调用函数和被调用函数放在同一个C文件中，这样编译器就知道了被调用函数生成的代码，并以此对调用函数进行一些优化。7 d: G  Y, C$ U" B" u: C! k

总结：
1） 尽量限制函数的参数，不要超过4个，这样函数调用的效率会更高。也可以将几个相关的参数组织在一个结构体中，用传递结构体指针来代替多个参数。
0 g; R: O) R. y+ q1 k2） 把比较小的被调用函数和调用函数放在同一个源文件中，并且要先定义，后调用，编译器就可以优化函数调用或者内联较小的函数。# n7 V5 w& C9 B% U( E* g
3） 对性能影响较大的重要函数可使用关键字_inline进行内联。4 V: [$ d& f9 {% ^! w( i
0 ^' h3 j) |( h9 K" q" @# T4 _: w5 j. |: r# w: W
1 x( q7 |6 g! e+ ?& y五、指针别名
: F) P7 K- }: l5 l% l2 g$ p& W. D  ^2 y& c3 z8 T: k% y! j
定义：当2个指针指向同一个地址对象时，这2个指针被称作该对象的别名（alias）。如果对其中一个指针进行写入，就会影响从另一个指针的读出。在一个函数中，编译器通常不知道哪一个指针是别名，哪一个不是；或哪一个指针有别名，哪一个没有。

7 X# A* ^8 X1 x& l0 c( ]避免指针别名：
1） 不要依赖编译器来消除包含存储器访问的公共子表达式，而应建立一个新的局部变量来保存这个表达式的值，这样可以保证只对这个表达式求一次值；
2） 避免使用局部变量的地址，否则对这个变量的访问效率会比较低。
' f6 @- V: v4 S
六、结构体安排2 N: ^6 s9 l. i% V( m# W
- c3 B3 v6 ^8 _5 ~; H* H. [在ARM上使用结构体有2个问题需要考虑：结构体地址边界对齐和结构体总的大小。
/ W+ t) x, _0 Q
获得高效结构体的原则：  K! O6 E7 a: }9 y! }+ t
- a; U7 P9 p* x% q1） 把所有8位大小的元素安排在结构体的前面；+ n8 x7 K4 U0 _! [! G3 F/ c: |: e
2） 以此安排16位、32位和64位的元素；
$ X( H: G/ V' @2 R/ C: e6 Q7 I. e3） 把所有数组和比较大的元素安排在结构体最后；" O" h+ t( o4 \, B7 V7 c
4） 对于一条指令，如果结构体太大而不能访问所有的元素，那么把元素组织到一个子结构体中。编译器可以维持单独的子结构体的指针。
# Y. x+ Z* x( t9 R: X3 d: Z# _; E: R, ]$ G# A( X9 M
" U4 f4 @% L1 I: \总结：
结构体元素要按照元素的大小来排列，以最小的元素放在开始，最大的元素安排在最后；避免使用很大的结构体，可以用层次化的小结构体来代替；为了提高可移植性，人工对API的结构体增加填充位，这样，结构体的安排将不会依赖与编译器；在API的结构体中要谨慎使用枚举类型。一个枚举类型的大小是编译器相关的。" m: {; h: n9 A% r6 O# j
) b" X, G$ }/ k9 r# W2 _0 R' j( u2 R' |! ?+ _; e
七、位域
/ Y. _* U0 f9 R% i( l注意事项：' E- k) y% U! K4 \9 O8 [, V
1） 应避免使用位域，而使用#define或者enum来定义屏蔽位；" h  D# ~: T4 E$ f: T
! v6 J4 S8 a6 U" d4 _/ f2） 使用整型逻辑运算AND、OR、“异或”操作和屏蔽对位域进行测试、取反和设置操作。这些操作编译效率高，还可以同时对多个位域进行测试、取反和设置。
4 H! H" J/ |* p0 C# _
八、边界不对齐数据和字节排列方式（大/小端）1 m: ^( h  b& W3 C1 _5 h  [8 e
) m0 a) o9 M- f$ E
边界不对齐数据和字节排列方式这2个问题，可使内存访问和移植问题复杂化。须考虑数组指针是否边界对齐，ARM配置是大端（big-endian），还是小端（little-endian）的存储器系统。+ Y9 t8 N! P$ c, n; ]/ S4 b
8 A% o: L; g$ ]; H; M
总结：
1 e1 e' D# J4 @7 G2 o: T1） 尽量避免使用边界不对齐的数据；# z% U; p! D2 u5 o! K
" U' A% B) N; A$ [  R& V  [2） 使用类型char *可指向任意字节边界的数据。通过读字节来访问数据，使用逻辑操作来组合数据，这样代码就不会依赖于边界是否对齐或者ARM的字节排列方式的配置；
3） 为了快速访问边界不对齐的结构体，可以根据指针边界和处理器的字节排序方式写出不同的程序变体。
; r- K) R- j5 x# ~* a. f: \5 p0 ?; Y- r! v( p
九、除法
7 e! g8 N0 M0 _0 h" `ARM硬件上不支持除法指令，当代码中出现除法运算时，ARM编译器会调用C库函数（有符号的除法调用_rt_sdiv，无符号的调用_rt_udiv），来实现除法操作。有许多不同类型的除法程序来适应不同的除数和被除数。
' q0 O  g9 ?6 S6 g& R7 `0 y6 h) N( w% k2 u1 T6 p; C
* c8 L2 x# h$ L$ g8 G总结：* g) d. B- T5 I( l5 p/ H$ `+ y
$ p% z# S* r; I/ ~- e+ M1） 尽可能避免使用除法。对环形缓冲区的处理可以不用除法。
' A3 R! ^) B7 m4 O) I* H2 j( ^2） 如果不能避免除法运算，那么尽可能考虑使用除法程序同时产生商n/d和余数n%d的好处。
3） 对于重复对同一除数d的除法，预先计算好s=(2k-1)/d。可用乘以s的2k位乘法来代替除以d的k位无符号整数除法。
1 S7 c% M1 l! F: l9 e4）使用2的整数次幂作除数。当2的整数次幂做除数时，编译器会自动将除法运算转换成移位运算。所以在编写程序算法时，尽量使用2的整数次幂做除数。
8 Z: Q5 t. \: X% K4 d* s( Q5）求余运算。可以将一些典型的求余运算进行转换，以避免在程序中使用除法运算。如：
0 G8 g8 {: Q2 Y

• ) T4 G9 s/ H% C1 g7 H* b* m& v! ~
  " G7 ~: ], u: Q/ s
  4 a5 t5 M1 G( {/ w

uint counter1(uint count){return (++count%60);}转换成：uint counter2(uint count){if (++count >=60)        count=0;return (count);}% ^" D8 [/ f% }% `: w. W3 w. v  H
+ C" M; Y$ a; y) z7 x( H* k8 Y5 L( _* C
十、浮点运算
大多数ARM处理器硬件上并不支持浮点运算。这样在一个对价格敏感的嵌入式应用系统中，可节省空间和降低功耗。除了硬件向量浮点累加器VFP和ARM7500FE上的浮点累加器FPA外，C编译器必须在软件上提供浮点支持。
% x% U0 U* k% L5 }1 k7 I: _3 V& E7 I5 q7 F& S0 t
5 j: l8 w7 W) d* c十一、内联函数和内嵌汇编
高效地调用函数，使用内联函数可以完全去除函数调用的开销，另外许多编译器允许在C源程序中使用内嵌汇编。使用包含汇编的内嵌函数，可以使编译器支持通常不能有效使用的ARM指令和优化方法。
8 R& v8 P8 Q9 N* C
内联函数和内嵌汇编最大的好处是，可以实现一些在C语言部分中通常难以完成的操作。使用内联函数要比使用#define宏定义更好，因为后者不检查函数参数和返回值的类型。