📘第06课：内存模型

Zig的内存模型直接映射硬件，没有隐式开销。理解内存布局是系统编程的基础，直接影响缓存性能和内存使用效率。

const std = @import("std");

pub fn main() !void {
    // 类型大小和对齐
    std.debug.print("u8: size={}, align={}\n", .{@sizeOf(u8), @alignOf(u8)});
    std.debug.print("u16: size={}, align={}\n", .{@sizeOf(u16), @alignOf(u16)});
    std.debug.print("u32: size={}, align={}\n", .{@sizeOf(u32), @alignOf(u32)});
    std.debug.print("u64: size={}, align={}\n", .{@sizeOf(u64), @alignOf(u64)});
    std.debug.print("f64: size={}, align={}\n", .{@sizeOf(f64), @alignOf(f64)});
    std.debug.print("*u8: size={}, align={}\n", .{@sizeOf(*u8), @alignOf(*u8)});

    // 结构体填充——字段顺序影响大小
    const Bad = struct { a: u8, b: u64, c: u8 };
    const Good = struct { b: u64, a: u8, c: u8 };
    std.debug.print("Bad: {} bytes (有填充)\n", .{@sizeOf(Bad)});   // 24
    std.debug.print("Good: {} bytes (优化)\n", .{@sizeOf(Good)});  // 16

    // 字段偏移量
    std.debug.print("Bad.a offset={}, Bad.b offset={}\n",
        .{@offsetOf(Bad, "a"), @offsetOf(Bad, "b")});

    // 位偏移（packed struct）
    std.debug.print("Good.b bitOffset={}\n", .{@bitOffsetOf(Good, "b")});
}

内存布局规则

• 字段按声明顺序排列，不可重排
• 每个字段按自身对齐要求对齐
• 结构体整体对齐=最大字段对齐
• 编译器自动在字段间插入填充字节
• 优化技巧：大字段优先声明，小字段合并减少padding

性能影响详解

缓存行大小64B，未对齐访问跨缓存行会降低2-3倍性能。TLB miss比缓存miss慢10-100倍。Bad结构体3个实例占72字节(3×24)，Good只占48字节(3×16)，后者缓存效率高50%。在遍历大量数据时，结构体大小直接影响缓存命中率——这是系统编程中最常见的性能陷阱之一。

常用内建函数

显式控制内存对齐，优化缓存和SIMD性能。Zig允许在字段和类型级别指定对齐：

const std = @import("std");

// 显式字段对齐——SIMD友好
const Vec4 = struct {
    x: f32 align(16),  // 16字节对齐，适合SSE
    y: f32,
    z: f32,
    w: f32,
};

// 缓存行对齐——避免false sharing
const PaddedCounter = struct {
    count: u64 align(64),
    _pad: [56]u8,
};

pub fn main() !void {
    var gpa = std.heap.GeneralPurposeAllocator(.{}){};
    defer _ = gpa.deinit();
    const allocator = gpa.allocator();

    // 64字节对齐分配（缓存行）
    const buf = try allocator.alignedAlloc(u8, 64, 1024);
    defer allocator.free(buf);

    // 验证对齐
    std.debug.print("64B对齐: {}\n", .{@intFromPtr(buf.ptr) % 64 == 0});

    // @alignCast指针对齐提升
    const aligned: [*]align(16) u8 = @alignCast(buf.ptr);
    _ = aligned;

    std.debug.print("Vec4 align={}\n", .{@alignOf(Vec4)});
    std.debug.print("PaddedCounter align={}\n", .{@alignOf(PaddedCounter)});
}

常见对齐场景

volatile阻止编译器优化读写操作，用于MMIO寄存器访问和信号处理。这是嵌入式和内核开发的关键概念：

const std = @import("std");

// MMIO寄存器结构
const UartReg = extern struct {
    data: u32,     // 偏移0x00
    status: u32,   // 偏移0x04
    ctrl: u32,     // 偏移0x08
    baud: u32,     // 偏移0x0C
};

pub fn main() !void {
    // volatile指针——每次读写都执行
    const uart: *volatile UartReg = @ptrFromInt(0x4000_0000);

    // volatile写——不会被优化掉
    uart.data = 0x41;  // 写'A'
    uart.ctrl = 0x01;  // 使能UART
    uart.baud = 0x08;  // 设置波特率

    // volatile读——每次都从内存读取
    const status = uart.status;
    std.debug.print("UART状态: 0x{X}\n", .{status});

    // 内存屏障——确保读写顺序
    std.atomic.fence(.SeqCst);
}

volatile vs atomic

网络协议(TCP/IP)用大端序，x86/ARM用小端序。Zig提供完整的字节序转换支持：

const std = @import("std");

pub fn main() !void {
    const value: u32 = 0x12345678;
    const bytes: [4]u8 = @bitCast(value);

    // 检测系统字节序
    if (std.mem.endian == .little) {
        std.debug.print("小端系统\n", .{});
    } else {
        std.debug.print("大端系统\n", .{});
    }

    // 字节序转换API
    const big = std.mem.nativeToBig(u32, value);     // 主机→网络序
    const little = std.mem.nativeToLittle(u32, value); // 主机→小端
    const back = std.mem.bigToNative(u32, big);        // 网络→主机序

    std.debug.print("原始:0x{X:0>8} 大端:0x{X:0>8} 还原:0x{X:0>8}\n", .{value, big, back});

    // 从字节流读取
    const net_bytes = [4]u8{0x12,0x34,0x56,0x78};
    const host_val = std.mem.readIntBig(u32, &net_bytes);
    std.debug.print("网络→主机:0x{X:0>8}\n", .{host_val});

    // 写入字节流
    var out: [4]u8 = undefined;
    std.mem.writeIntBig(u32, &out, value);
}

性能分析

小端系统(x86/ARM)上，nativeToLittle是no-op(零开销)。nativeToBig编译为bswap指令(1个时钟周期)。readInt/writeInt函数使用unaligned访问避免对齐问题。在协议解析热路径中，字节序转换开销可忽略。