标签: memory-alignment

  struct {              /* Fileheader */
    uchar file_version[4];
    uchar options[2];
    uchar header_length[2];
    uchar state_info_length[2];
    uchar base_info_length[2];
    uchar base_pos[2];
    uchar key_parts[2];         /* Key parts */
    uchar unique_key_parts[2];      /* Key parts + unique parts */
    uchar keys;             /* number of keys in file */
    uchar uniques;          /* number of UNIQUE definitions */
    uchar language;         /* Language for indexes */
    uchar max_block_size_index;     /* max keyblock size */
    uchar fulltext_keys;
    uchar not_used;                     /* To align to 8 */
  } header;

以上是从MySQL源码中提取的,

为什么要费心去做8？

在iOS应用程序中,我有一个看起来像这样的结构

typedef struct _Pixel {
  signed char r;
  signed char g;
  signed char b;
} Pixel;

在我的代码中,我使用calloc分配了这些数组:

Pixel* buff = calloc(width * height, sizeof(Pixel));

现在,这在模拟器中完美运行,但在设备上,如果我尝试访问buff[width * height - 1](即最后一个元素buff),我得到一个EXC_BAD_ACCESS.

这对我来说没有意义,所以经过几个小时的调试后,我想知道它是否是某种对齐问题,所以我试着突发奇想:

typedef struct _Pixel {
  signed char r;
  signed char g;
  signed char b;
  signed char padding;
} Pixel;

使Pixel的大小为2的幂.

这修复了EXC_BAD_ACCESS,但它非常奇怪.有没有人对这里发生的事情有任何见解？我只是通过填充结构来掩盖底层问题,或者对齐确实会导致访问不良(我认为对齐只会影响性能,而不是正确性).

在我的代码中，我必须考虑一个数组数组，其中内部数组的尺寸是固定的。为了利用STL算法，将数据实际存储为数组数组很有用，但是我还需要将该数据传递给C库，该库采用扁平化的C样式数组。

能够以可移植的方式廉价地转换（即展平）多维数组将是很棒的。我会坚持一个非常简单的案例，真正的问题是更笼统的。

struct my_inner_array { int data[3]; };
std::vector<my_inner_array> x(15);

是

&(x[0].data[0])

指向大小为45 * sizeof（int）的连续内存块的指针，该内存块包含与x相同的条目？还是我需要担心对齐？恐怕这将对我有用（至少对于某些数据类型和内部数组大小而言），但它不是可移植的。

1. 此代码可移植吗？
2. 如果没有，是否有办法使其起作用？
3. 如果没有，您对我有什么建议？
4. 如果my_inner_array不是POD结构，但包含某些方法（只要该类不包含任何虚拟方法），它是否会发生任何改变？

我的问题由两部分组成.

1. 我注意到使用cc编译器在sparc(sun)上的memalign(block_size,bytes)不会检查字节是2的幂,而不是在intel linux上的memalign和使用mvsc编译器的windows上的_aligned_malloc检查字节是否为2的力量.

这是一个阳光下的虫子,有补丁还是我需要自己写一个memalign.

1. 另外我有一个结构(不是我的代码):

   typedef struct CLHLockStruct {
       volatile CLHLockNode CACHE_ALIGN *Tail ;
       volatile CLHLockNode CACHE_ALIGN *MyNode[N_THREADS] ;
       volatile CLHLockNode CACHE_ALIGN *MyPred[N_THREADS] ;
   } CLHLockStruct;
   

   Run Code Online (Sandbox Code Playgroud)

我在MVSC下编译(visual studio 2008):

    CACHE_LINE_SIZE = 64
    CACHE_ALIGN = __declspec(align(CACHE_LINE_SIZE)) 
    N_THREADS = 8
    sizeof(CLHLockStruct)=192

该代码最初是为sparc架构编写的,我尝试将其迁移到MVSC而无需更改代码.

在他们的代码中他们使用memalign(CACHE_LINE_SIZE,sizeof(CLHLockStruct)),并且我已将其更改为_aligned_malloc,我的问题是sizeof(CLHLockStruct)不是2的幂,我可能会写一些函数找到下一个数字是2的力量.

他们是更好的方法吗？

EDIT1

我如何填充这个结构,使其大小为2的幂？

EDIT2

是否有一个像_aligned_malloc和malloc一样的函数:返回一个与block_size的倍数对齐的内存指针,但不要求字节为2的幂？

我有两个结构.

t_struct_inner {
  int a;
  ... // a lot more members
}

t_struct_outer {
  t_struct_inner[1000] inners;
  t_struct_outer* next;
}

我t_struct_outer在我的代码中使用malloc .我希望t_struct_inner缓存对齐.我的解决方案是使用

 __attribute__((aligned(
       ((sizeof(t_struct_inner)/CACHE_LINE_SIZE)+1) * CACHE_LINE_SIZE
)))

但显然我不能这样做,因为我不能sizeof在这里使用.我不想硬编码值aligned.我有什么想法可以实现上述目标？

在以下链接中:http://msdn.microsoft.com/en-us/library/ms684122(VS.85).aspx,据说"对正确对齐的32位变量的简单读写是原子操作".我想知道在c ++程序中是否所有32位变量默认都是正确对齐的.换句话说,有些情况是32位变量无法正确对齐.

我知道将Eigen类型与动态内存结合使用时会出现对齐问题。因此，我决定Eigen::DontAlign 根据此页面禁用向量化，但是以下代码仍在执行时一致地引发SIGSEGV。如果有人可以阐明为什么会发生，我会很高兴。从我的角度来看，使用Eigen::DontAlign应该使我摆脱了对齐的复杂性。

#include <Eigen/Dense>
#include <vector>

int main()
{
    using vec_t = Eigen::Matrix< double, 4, 1, Eigen::DontAlign >;
    std::vector< vec_t > foo;
    foo.emplace_back( 0.0, 0.0, 0.0, 1.0 );
    vec_t vec{ -4.0, 1.0, 3.0, 1.0 };
    foo.push_back( vec );
}

GDB输出：

Program received signal SIGSEGV, Segmentation fault.
0x0000000000408bed in Eigen::internal::evaluator<Eigen::PlainObjectBase<Eigen::Matrix<double, 4, 1, 2, 4, 1> > >::packet<0, double __vector(4)>(long long, long long) const (this=0x22fa90, row=0, col=0)
    at C:/Dev/Eigen/Eigen/src/Core/CoreEvaluators.h:197
197           return ploadt<PacketType, LoadMode>(m_data + row + col * …

我正在使用GCC为Cortex M7编译此代码:

// copy manually
void write_test_plain(uint8_t * ptr, uint32_t value)
{
    *ptr++ = (u8)(value);
    *ptr++ = (u8)(value >> 8);
    *ptr++ = (u8)(value >> 16);
    *ptr++ = (u8)(value >> 24); 
}

// copy using memcpy
void write_test_memcpy(uint8_t * ptr, uint32_t value)
{
    void *px = (void*)&value;
    memcpy(ptr, px, 4);
}

int main(void) 
{
    extern uint8_t data[];
    extern uint32_t value;

    // i added some offsets to data to
    // make sure the compiler cannot
    // assume it's aligned in memory

    write_test_plain(data …

我注意到std::aligned_alloc()进入C ++ 17，我喜欢它。但是-当我需要重新分配时会发生什么？我可以手动执行此操作（假设当前分配的地址处的可用空间仅是我要求的空间量），但是标准库中是否不应该提供此功能？

我写了一个简单的例子：

#include <iostream>

int main() {
    void* byte1 = ::operator new(1);
    void* byte2 = ::operator new(1);
    void* byte3 = malloc(1);
    std::cout << "byte1: " << byte1 << std::endl;
    std::cout << "byte2: " << byte2 << std::endl;
    std::cout << "byte3: " << byte3 << std::endl;
    return 0;
}

运行示例，我得到以下结果：

字节1：0x1f53e70

字节2：0x1f53e90

字节3：0x1f53eb0

每次我分配一个内存字节时，它总是16个字节对齐。为什么会这样？

我在GCC 5.4.0和GCC 7.4.0上测试了此代码，并得到了相同的结果。