C++内存对齐从硬件基础到性能优化实战

struct example1 {
    char a;      // 大小1，对齐1。偏移地址0。
    int b;       // 大小4，对齐4。偏移地址必须是4的倍数。所以编译器在a后面插入3字节填充（偏移1-3）。
    char c;      // 大小1，对齐1。紧接在b之后，偏移地址8。
};
// 此时，sizeof(example1) 似乎是 1 + 3(padding) + 4 + 1 = 9。
// 但规则2：整体大小必须是最大对齐系数（max(1,4,1)=4）的整数倍。
// 9不是4的倍数，所以编译器在最后再插入3字节填充（偏移9-11）。
// 最终 sizeof(example1) = 12。

#include <iostream>
#include <cstddef> // for offsetof

struct example1 {
    char a;
    int b;
    char c;
};

int main() {
    std::cout << "sizeof: " << sizeof(example1) << std::endl; // 输出 12
    std::cout << "offsets:\n";
    std::cout << "a: " << offsetof(example1, a) << std::endl; // 0
    std::cout << "b: " << offsetof(example1, b) << std::endl; // 4
    std::cout << "c: " << offsetof(example1, c) << std::endl; // 8
    return 0;
}

// 强制一个结构体按16字节对齐，常用于sse/avx指令需要的对齐
struct alignas(16) vec4 {
    float x, y, z, w;
};
static_assert(alignof(vec4) == 16, "vec4 must be 16-byte aligned");

// 也可以用于单个变量
alignas(64) char cacheline[256]; // 让这个数组起始于一个缓存行(通常64字节)边界，减少伪共享

#pragma pack(push, 1) // 将当前对齐设置压栈，并设置对齐系数为1（即无对齐，紧密排列）
struct networkpacket {
    uint16_t header; // 偏移 0
    uint32_t seq;    // 偏移 2 （如果没有pack，这里会有2字节填充）
    uint8_t type;    // 偏移 6
    uint32_t data;   // 偏移 7 （如果没有pack，这里会有1字节填充）
}; // 总大小 = 2+4+1+4 = 11 字节
#pragma pack(pop) // 恢复之前的对齐设置

#include <memory>
#include <iostream>

void* allocate_aligned(size_t size, size_t alignment) {
    // 过度分配以确保有空间进行对齐调整
    size_t total_size = size + alignment - 1;
    void* raw_ptr = std::malloc(total_size);
    if (!raw_ptr) return nullptr;

    // 调整指针到对齐边界
    void* aligned_ptr = raw_ptr;
    std::align(alignment, size, aligned_ptr, total_size);

    // 在实际项目中，你需要记录raw_ptr以便后续正确释放
    // 这里为简化，直接返回（存在内存泄漏风险，仅作演示）
    return aligned_ptr;
}

struct alignas(64) counter { // 确保每个counter独占一个缓存行
    std::atomic<int64_t> value{0};
    char padding[64 - sizeof(std::atomic<int64_t>)]; // 显式填充剩余字节
};

counter counters[4]; // 四个计数器，每个都起始于独立的缓存行

#include <immintrin.h> // avx

void add_arrays(float* a, float* b, float* result, size_t n) {
    // 假设a, b, result都已保证是32字节对齐的
    for (size_t i = 0; i < n; i += 8) { // avx一次处理8个float
        __m256 vec_a = _mm256_load_ps(a + i); // _mm256_load_ps 要求32字节对齐
        __m256 vec_b = _mm256_load_ps(b + i);
        __m256 vec_result = _mm256_add_ps(vec_a, vec_b);
        _mm256_store_ps(result + i, vec_result); // _mm256_store_ps 要求32字节对齐
    }
    // 处理剩余元素...
}

#include <cstdlib>
#ifdef _win32
#include <malloc.h>
#endif

void* aligned_alloc(size_t size, size_t alignment) {
#ifdef _win32
    return _aligned_malloc(size, alignment);
#else
    // posix / c11
    void* ptr = nullptr;
    int ret = posix_memalign(&ptr, alignment, size);
    return (ret == 0) ? ptr : nullptr;
#endif
}

void aligned_free(void* ptr) {
#ifdef _win32
    _aligned_free(ptr);
#else
    free(ptr);
#endif
}

struct memoryblock {
    memoryblock* next;
    size_t size;
    // 紧接着这里就是用户可用内存区域
};
// 分配时，需要确保返回给用户的指针是按要求对齐的。
void* memorypool::allocate(size_t size, size_t alignment) {
    // 1. 计算总需求：头大小 + 用户大小 + (对齐-1)
    size_t total_size = sizeof(memoryblock) + size + alignment - 1;
    // 2. 分配原始内存
    char* raw_ptr = static_cast<char*>(internal_alloc(total_size));
    // 3. 计算用户区域的起始地址（对齐后）
    char* user_ptr = raw_ptr + sizeof(memoryblock);
    size_t offset = (reinterpret_cast<uintptr_t>(user_ptr) % alignment);
    if (offset != 0) {
        user_ptr += (alignment - offset);
    }
    // 4. 将头信息存储在用户指针之前
    memoryblock* block = reinterpret_cast<memoryblock*>(user_ptr - sizeof(memoryblock));
    block->next = nullptr;
    block->size = size;
    // 5. 返回对齐后的用户指针
    return user_ptr;
}

struct sensordata {
    uint32_t timestamp;
    float values[3];
    bool isvalid;
};
// 在x86-64 linux上，sizeof(sensordata)可能是20（4+12+1+3填充）。
// 在另一个对齐规则不同的平台上，大小可能是16或24。
// 直接 fwrite(&data, sizeof(data), 1, file) 会导致数据错位。

class sensordata {
public:
    std::vector<uint8_t> serialize() const {
        std::vector<uint8_t> buffer;
        buffer.reserve(4 + 4*3 + 1); // 预估大小
        write_uint32(buffer, timestamp);
        for (float v : values) write_float(buffer, v);
        write_uint8(buffer, isvalid ? 1 : 0);
        return buffer;
    }
    bool deserialize(const uint8_t* data, size_t size) {
        // 按协议逐个字段读取，进行字节序转换
        // ...
    }
private:
    uint32_t timestamp;
    float values[3];
    bool isvalid;
    // 辅助写入函数，处理字节序
};

struct particle {
    glm::vec3 position; // 12字节，对齐4（假设vec3是3个float）
    glm::vec3 velocity; // 12字节，对齐4
    glm::vec4 color;    // 16字节，对齐16（vec4通常是16对齐）
    float life;         // 4字节，对齐4
    bool active;        // 1字节，对齐1
};
// 在常见平台上，sizeof(particle) 可能是 12 + 4(填充) + 12 + 4(填充) + 16 + 4 + 1 + 3(填充) = 56 字节。

// “热”数据：每帧更新
struct alignas(16) particledynamic { // 按16对齐，方便simd
    glm::vec3 position;
    glm::vec3 velocity;
    float life;
    // 这里可能还有4字节填充，以满足16对齐，但总大小32字节，是缓存行(64b)的一半，很紧凑。
};
static_assert(sizeof(particledynamic) == 32, "check layout");

// “冷”数据：初始化或渲染时使用
struct particlestatic {
    glm::vec4 color;
    // 可以放其他不常变的属性，如大小、纹理id等
};

class particlesystem {
    std::vector<particledynamic> dynamics;
    std::vector<particlestatic> statics;
public:
    void update(float dt) {
        // 循环遍历dynamics，只操作位置、速度、生命周期。
        // 所有数据紧凑，缓存命中率高，甚至可以用avx并行处理。
        for (auto& p : dynamics) {
            p.position += p.velocity * dt;
            p.life -= dt;
        }
    }
    void render() {
        // 渲染时需要颜色，此时再通过索引关联dynamics和statics。
    }
};