C内存对齐问题

C内存对齐问题

=====================================================================================
from:

Specific structure packing when using the GNU C Compiler

The GNU C compiler does not support the #pragma directives. In particular it does not support the "#pragma pack" directive. So when using the GNU C compiler, you can ensure structure packing in one of two ways

    * Define the structure appropriately so that it is intrinsically packed. This is hard to do and requires an understanding of how the compiler behaves with respect to alignment on the target machine. Also it is hard to maintain.
    * Use the "packed" attribute against the members of a structure. This attribute mechanism is an extension to the GNU C compiler. An example of how you would do this is below.

          struct test
          {
                  unsigned char  field1 __attribute__((__packed__));
                  unsigned short field2 __attribute__((__packed__));
                  unsigned long  field3 __attribute__((__packed__));
          } var1, var2;


      Note the use of the keyword "__attribute__" with the attribute "__packed__" within the double brackets (before the terminating semicolon of each member variable declaration).

      An alternate way of doing the above is as below.

          struct test
          {
                  unsigned char  field1;
                  unsigned short field2;
                  unsigned long  field3;
          } __attribute__((__packed__));
         
          typedef struct test test_t;
         
          test_t var1, var2;

      This will ensure that all members of the structure are packed. Note that this doesn't seem to work right if you try to combine the typedef and the struct definition or if you combine variable declarations with the structure definition.
=====================================================================================
from:

内存对齐与ANSI C中struct型数据的内存布局[1]
[入库：2005年8月18日] [更新：2007年3月24日]
本文简介：选择自 soloist 的 blog
首页 下页 尾页 [1] [2] [3] [4]

    当在c中定义了一个结构类型时，它的大小是否等于各字段(field)大小之和？
编译器将如何在内存中放置这些字段？ansi c对结构体的内存布局有什么要求？
而我们的程序又能否依赖这种布局？这些问题或许对不少朋友来说还有点模糊
那么本文就试着探究它们背后的秘密。

    首先，至少有一点可以肯定，那就是ansi c保证结构体中各字段在内存中
出现的位置是随它们的声明顺序依次递增的，并且第一个字段的首地址等于整
个结构体实例的首地址。比如有这样一个结构体：
 
  struct vector{int x,y,z;} s;
  int *p,*q,*r;
  struct vector *ps;
 
  p = &s.x;
  q = &s.y;
  r = &s.z;
  ps = &s;

  assert(p < q);
  assert(p < r);
  assert(q < r);
  assert((int*)ps == p);
  // 上述断言一定不会失败

    这时，有朋友可能会问:"标准是否规定相邻字段在内存中也相邻?"。 唔，
对不起，ansi c没有做出保证，你的程序在任何时候都不应该依赖这个假设。
那这是否意味着我们永远无法勾勒出一幅更清晰更精确的结构体内存布局图？
哦，当然不是。不过先让我们从这个问题中暂时抽身，关注一下另一个重要问
题————内存对齐。

    许多实际的计算机系统对基本类型数据在内存中存放的位置有限制，它们
会要求这些数据的首地址的值是某个数k(通常它为4或8)的倍数，这就是所谓的
内存对齐，而这个k则被称为该数据类型的对齐模数(alignment modulus)。
当一种类型s的对齐模数与另一种类型t的对齐模数的比值是大于1的整数，我们
就称类型s的对齐要求比t强(严格)，而称t比s弱(宽松)。这种强制的要求一来
简化了处理器与内存之间传输系统的设计，二来可以提升读取数据的速度。比
如这么一种处理器，它每次读写内存的时候都从某个8倍数的地址开始，一次
读出或写入8个字节的数据，假如软件能保证double类型的数据都从8倍数地址
开始，那么读或写一个double类型数据就只需要一次内存操作。否则，我们就
可能需要两次内存操作才能完成这个动作，因为数据或许恰好横跨在两个符合
对齐要求的8字节内存块上。某些处理器在数据不满足对齐要求的情况下可能会
出错，但是intel的ia32架构的处理器则不管数据是否对齐都能正确工作。不过
intel奉劝大家，如果想提升性能，那么所有的程序数据都应该尽可能地对齐。
win32平台下的微软c编译器(cl.exe for 80x86)在默认情况下采用如下的对齐规
则: 任何基本数据类型t的对齐模数就是t的大小，即sizeof(t)。比如对于double
类型(8字节)，就要求该类型数据的地址总是8的倍数，而char类型数据(1字节)则
可以从任何一个地址开始。linux下的gcc奉行的是另外一套规则(在资料中查得，
并未验证，如错误请指正):任何2字节大小(包括单字节吗?)的数据类型(比如short)
的对齐模数是2，而其它所有超过2字节的数据类型(比如long,double)都以4为对齐模数。

    现在回到我们关心的struct上来。ansi c规定一种结构类型的大小是它所有
字段的大小以及字段之间或字段尾部的填充区大小之和。嗯？填充区？对，这就
是为了使结构体字段满足内存对齐要求而额外分配给结构体的空间。那么结构体
本身有什么对齐要求吗？有的，ansi c标准规定结构体类型的对齐要求不能比它
所有字段中要求最严格的那个宽松，可以更严格(但此非强制要求，vc7.1就仅仅
是让它们一样严格)。我们来看一个例子(以下所有试验的环境是
intel celeron 2.4g + win2000 pro + vc7.1，内存对齐编译选项是"默认"，即
不指定/zp与/pack选项):

  typedef struct ms1
  {
     char a;
     int b;
  } ms1;

    假设ms1按如下方式内存布局(本文所有示意图中的内存地址从左至右递增):
         _____________________________
         |       |                   |
         |   a   |        b          |
         |       |                   |
         +---------------------------+
 bytes       1             4

    因为ms1中有最强对齐要求的是b字段(int)，所以根据编译器的对齐规则以及
ansi c标准，ms1对象的首地址一定是4(int类型的对齐模数)的倍数。那么上述内
存布局中的b字段能满足int类型的对齐要求吗？嗯，当然不能。如果你是编译器，
你会如何巧妙安排来满足cpu的癖好呢？呵呵，经过1毫秒的艰苦思考，你一定得出
了如下的方案：

         _______________________________________
         |       |\\\\\\\\\\\|                 |
         |   a   |\\padding\\|       b         |
         |       |\\\\\\\\\\\|                 |
         +-------------------------------------+
 bytes:    1         3             4

    这个方案在a与b之间多分配了3个填充(padding)字节，这样当整个struct对象
首地址满足4字节的对齐要求时，b字段也一定能满足int型的4字节对齐规定。那么
sizeof(ms1)显然就应该是8，而b字段相对于结构体首地址的偏移就是4。非常好理
解，对吗？现在我们把ms1中的字段交换一下顺序:

  typedef struct ms2
  {
     int a;
     char b;
  } ms2;

    或许你认为ms2比ms1的情况要简单，它的布局应该就是

       _______________________
       |             |       |
       |     a       |   b   |
       |             |       |
       +---------------------+
 bytes:      4           1

    因为ms2对象同样要满足4字节对齐规定，而此时a的地址与结构体的首地址相
等，所以它一定也是4字节对齐。嗯，分析得有道理，可是却不全面。让我们来考
虑一下定义一个ms2类型的数组会出现什么问题。c标准保证，任何类型(包括自定
义结构类型)的数组所占空间的大小一定等于一个单独的该类型数据的大小乘以数
组元素的个数。换句话说，数组各元素之间不会有空隙。按照上面的方案，一个
ms2数组array的布局就是:

|<-    array[1]     ->|<-    array[2]     ->|<- array[3] .....
__________________________________________________________
|             |       |              |      |
|     a       |   b   |      a       |   b  |.............
|             |       |              |      |
+----------------------------------------------------------
bytes:  4         1          4           1

    当数组首地址是4字节对齐时，array[1].a也是4字节对齐，可是array[2].a呢？
array[3].a ....呢？可见这种方案在定义结构体数组时无法让数组中所有元素的字段
都满足对齐规定，必须修改成如下形式:

       ___________________________________
       |             |       |\\\\\\\\\\\|
       |     a       |   b   |\\padding\\|
       |             |       |\\\\\\\\\\\|
       +---------------------------------+
bytes:      4           1         3

    现在无论是定义一个单独的ms2变量还是ms2数组，均能保证所有元素的所有字段
都满足对齐规定。那么sizeof(ms2)仍然是8，而a的偏移为0，b的偏移是4。

    好的，现在你已经掌握了结构体内存布局的基本准则，尝试分析一个稍微复杂点的类型吧。

  typedef struct ms3
  {
     char a;
     short b;
     double c;
  } ms3;

    我想你一定能得出如下正确的布局图:
        padding
           |
      _____v_________________________________
      |   |\|     |\\\\\\\\\|               |
      | a |\|  b  |\padding\|       c       |
      |   |\|     |\\\\\\\\\|               |
      +-------------------------------------+
bytes:  1  1   2       4            8
         
    sizeof(short)等于2，b字段应从偶数地址开始，所以a的后面填充一个字节，而
sizeof(double)等于8，c字段要从8倍数地址开始，前面的a、b字段加上填充字节已经有4 bytes，
所以b后面再填充4个字节就可以保证c字段的对齐要求了。sizeof(ms3)等于16，b的偏移是2，c的
偏移是8。接着看看结构体中字段还是结构类型的情况:

  typedef struct ms4
  {
     char a;
     ms3 b;
  } ms4;

    ms3中内存要求最严格的字段是c，那么ms3类型数据的对齐模数就与double的一致(为8)，a字段
后面应填充7个字节，因此ms4的布局应该是:
       _______________________________________
       |       |\\\\\\\\\\\|                 |
       |   a   |\\padding\\|       b         |
       |       |\\\\\\\\\\\|                 |
       +-------------------------------------+
 bytes:    1         7             16

    显然，sizeof(ms4)等于24，b的偏移等于8。

    在实际开发中，我们可以通过指定/zp编译选项来更改编译器的对齐规则。比如指定/zpn(vc7.1
中n可以是1、2、4、8、16)就是告诉编译器最大对齐模数是n。在这种情况下，所有小于等于n字节的
基本数据类型的对齐规则与默认的一样，但是大于n个字节的数据类型的对齐模数被限制为n。事实上，
vc7.1的默认对齐选项就相当于/zp8。仔细看看msdn对这个选项的描述，会发现它郑重告诫了程序员不
要在mips和alpha平台上用/zp1和/zp2选项，也不要在16位平台上指定/zp4和/zp8(想想为什么？)。改
变编译器的对齐选项，对照程序运行结果重新分析上面4种结构体的内存布局将是一个很好的复习。

    到了这里，我们可以回答本文提出的最后一个问题了。结构体的内存布局依赖于cpu、操作系统、编
译器及编译时的对齐选项，而你的程序可能需要运行在多种平台上，你的源代码可能要被不同的人用不同
的编译器编译(试想你为别人提供一个开放源码的库)，那么除非绝对必需，否则你的程序永远也不要依赖
这些诡异的内存布局。顺便说一下，如果一个程序中的两个模块是用不同的对齐选项分别编译的，那么它
很可能会产生一些非常微妙的错误。如果你的程序确实有很难理解的行为，不防仔细检查一下各个模块的
编译选项。

    思考题:请分析下面几种结构体在你的平台上的内存布局，并试着寻找一种合理安排字段声明顺序的方法
以尽量节省内存空间。

    a. struct p1 { int a; char b; int c; char d; };
    b. struct p2 { int a; char b; char c; int d; };

    c. struct p3 { short a[3]; char b[3]; };
    d. struct p4 { short a[3]; char *b[3]; };
    e. struct p5 { struct p2 *a; char b; struct p1 a[2];  };

参考资料:

    【1】《深入理解计算机系统(修订版)》，
         (著)randal e.bryant; david o'hallaron，
         (译)龚奕利 雷迎春，
         中国电力出版社，2004
  
    【2】《c: a reference manual》(影印版)，
         (著)samuel p.harbison; guy l.steele，
         人民邮电出版社，2003
=====================================================================================
以上文章的验证代码:
cjash@chjianash:~\> ./mem_align
sizeof (aa1_st): 8
sizeof (aa2_st): 8
sizeof (aa3_st): 16
sizeof (aa4_st): 12
cjash@chjianash:~\> cat mem_align.c

#include
#include
#include

typedef struct aa1 {
  char a;
  int b;
} aa1_st;

typedef struct aa2 {
  int a;
  char b;
} aa2_st;

typedef struct aa3 {
  char a;
  short b;
  double c;
} aa3_st;

typedef struct aa4 {
  char a;
  aa2_st b;
} aa4_st;


int
main(void)
{
  printf("sizeof (aa1_st): %d\n", sizeof(aa1_st));
  printf("sizeof (aa2_st): %d\n", sizeof(aa2_st));
  printf("sizeof (aa3_st): %d\n", sizeof(aa3_st));
  printf("sizeof (aa4_st): %d\n", sizeof(aa4_st));
  return 0;
}
cjash@chjianash:~\> emacs mem_align.c
cjash@chjianash:~\> ./mem_align
cjash@chjianash:~\> gcc -o mem_align  mem_align.c
cjash@chjianash:~\> ./mem_align
sizeof (aa1_st): 8
sizeof (aa2_st): 8
sizeof (aa3_st): 16
sizeof (aa4_st): 12

sizeof (double): 8
sizeof (int): 4
sizeof (short): 2
sizeof (char): 1
cjash@chjianash:~\> cat mem_align.c

#include
#include
#include

typedef struct aa1 {
  char a;
  int b;
} aa1_st;

typedef struct aa2 {
  int a;
  char b;
} aa2_st;

typedef struct aa3 {
  char a;
  short b;
  double c;
} aa3_st;

typedef struct aa4 {
  char a;
  aa2_st b;
} aa4_st;


int
main(void)
{
  printf("sizeof (aa1_st): %d\n", sizeof(aa1_st));
  printf("sizeof (aa2_st): %d\n", sizeof(aa2_st));
  printf("sizeof (aa3_st): %d\n", sizeof(aa3_st));
  printf("sizeof (aa4_st): %d\n\n", sizeof(aa4_st));

  printf("sizeof (double): %d\n", sizeof(double));
  printf("sizeof (int): %d\n", sizeof(int));
  printf("sizeof (short): %d\n", sizeof(short));
  printf("sizeof (char): %d\n", sizeof(char));
  return 0;
}
cjash@chjianash:~\>  
====================================================================================

 
=====================================================================================

 
=====================================================================================