Memory Layout and repr in Rust: FFI Safety, Alignment, and Performance

use std::mem::{size_of, align_of, offset_of};

struct Naive {
    a: u8,    // 1 byte
    b: u64,   // 8 bytes
    c: u32,   // 4 bytes
}

struct Optimized {
    b: u64,   // 8 bytes
    c: u32,   // 4 bytes
    a: u8,    // 1 byte
    // 3 bytes padding to make size multiple of alignment (8)
}

fn main() {
    println!("Naive:     size={}, align={}", size_of::<Naive>(), align_of::<Naive>());
    // Naive:     size=24, align=8  (7 bytes padding after a, 4 after c)

    println!("Optimized: size={}, align={}", size_of::<Optimized>(), align_of::<Optimized>());
    // Optimized: size=16, align=8  (3 bytes padding at end)
}

struct MyStruct {
    x: u8,
    y: i64,
    z: u16,
}

// Rust may reorder to: y, z, x for optimal packing
// You cannot assume x is at offset 0

// This struct can be safely passed to C code
#[repr(C)]
pub struct NetworkPacketHeader {
    pub version:  u8,
    pub flags:    u8,
    pub length:   u16,
    pub checksum: u32,
    pub src_ip:   [u8; 4],
    pub dst_ip:   [u8; 4],
}

fn main() {
    use std::mem::{size_of, offset_of};
    println!("size={}", size_of::<NetworkPacketHeader>()); // 16

    // Offsets are predictable with repr(C)
    // version: 0, flags: 1, length: 2, checksum: 4, src_ip: 8, dst_ip: 12
}

// Rust side
#[repr(C)]
pub struct Point {
    pub x: f64,
    pub y: f64,
}

extern "C" {
    fn distance(a: *const Point, b: *const Point) -> f64;
}

fn main() {
    let a = Point { x: 0.0, y: 0.0 };
    let b = Point { x: 3.0, y: 4.0 };
    let d = unsafe { distance(&a, &b) };
    println!("{}", d); // 5.0
}

// C side (mylib.c)
#include <math.h>
typedef struct { double x; double y; } Point;
double distance(const Point* a, const Point* b) {
    double dx = a->x - b->x, dy = a->y - b->y;
    return sqrt(dx*dx + dy*dy);
}

// C-compatible enum — integer underneath
#[repr(C)]
pub enum Status {
    Active   = 0,
    Inactive = 1,
    Pending  = 2,
}

// You can specify the discriminant type with repr(C, u8) etc.
#[repr(C, u8)]
pub enum SmallEnum {
    A = 0,
    B = 1,
    C = 255,
}

#[repr(transparent)]
pub struct UserId(pub u64);

#[repr(transparent)]
pub struct NonNullPtr<T>(*mut T);

// Without repr(transparent), the wrapper might have different layout
// than the inner type, breaking FFI expectations.

extern "C" {
    fn get_user_data(id: u64) -> *mut u8;
}

// With repr(transparent), UserId has the same ABI as u64
// This is safe to call:
fn get_user(id: UserId) -> *mut u8 {
    unsafe { get_user_data(id.0) }
}

#[repr(packed)]
struct UdpHeader {
    src_port:  u16,
    dst_port:  u16,
    length:    u16,
    checksum:  u16,
}

fn main() {
    println!("size={}", std::mem::size_of::<UdpHeader>()); // 8 (no padding)
}

#[repr(packed)]
struct Packed { a: u8, b: u32 }

fn main() {
    let p = Packed { a: 1, b: 2 };

    // UNSAFE — b might not be at a 4-byte aligned address
    // let r = &p.b; // Compiler warning/error in recent Rust

    // SAFE — copy the value first
    let b = p.b; // Loads unaligned, but as a value not reference
    println!("{}", b);
}

use std::ptr;

#[repr(packed, C)]
struct PacketHeader {
    kind: u8,
    length: u32,
}

fn read_length(header: &PacketHeader) -> u32 {
    // SAFETY: We read via unaligned accessor — always safe regardless of alignment
    unsafe { ptr::read_unaligned(ptr::addr_of!(header.length)) }
}

// Cache-line aligned struct (64 bytes on x86_64)
// Prevents false sharing between CPU cores
#[repr(align(64))]
struct CacheAlignedCounter {
    value: std::sync::atomic::AtomicU64,
    _pad: [u8; 56], // Fill the rest of the cache line
}

// SIMD-aligned buffer for vectorized operations
#[repr(align(32))]
struct Avx2Buffer {
    data: [f32; 8], // 8 x f32 = 32 bytes = one AVX2 register
}

fn main() {
    println!("{}", std::mem::align_of::<CacheAlignedCounter>()); // 64
    println!("{}", std::mem::align_of::<Avx2Buffer>());           // 32

    // Useful for lock-free concurrent counters
    // Two CacheAlignedCounters will be on different cache lines
    // → no false sharing between threads updating different counters
}

use std::sync::atomic::{AtomicU64, Ordering};
use std::sync::Arc;
use std::thread;

// BAD: Both counters fit in one cache line → false sharing
struct BadCounters {
    a: AtomicU64,
    b: AtomicU64,
}

// GOOD: Each counter on its own cache line
#[repr(align(64))]
struct PaddedCounter(AtomicU64);

struct GoodCounters {
    a: PaddedCounter,
    b: PaddedCounter,
}

fn main() {
    use std::mem::size_of;

    // Reference is non-null, so None can be represented as null
    println!("{}", size_of::<&i32>());             // 8
    println!("{}", size_of::<Option<&i32>>());     // 8 (same! niche optimization)

    // For types with no niche, discriminant adds size
    println!("{}", size_of::<Option<u64>>());      // 16 (8 + 8 for discriminant)

    // Box also has niche optimization (non-null pointer)
    println!("{}", size_of::<Option<Box<i32>>>()); // 8
}

// BAD: hot fields scattered across cache lines
struct ScatteredHotFields {
    id:          u64,   // accessed every request
    created_at:  u64,   // rarely accessed
    updated_at:  u64,   // rarely accessed
    deleted:     bool,  // accessed every request
    name:        String, // rarely accessed in hot path
    count:       u32,   // accessed every request
}

// GOOD: hot fields in first cache line
struct CacheOptimized {
    // Hot path data (fits in one 64-byte cache line: 8+1+3pad+4 = 16 bytes)
    id:    u64,
    deleted: bool,
    // 3 bytes implicit padding
    count: u32,

    // Cold data (second cache line, only loaded when needed)
    created_at: u64,
    updated_at: u64,
    name: String, // 24 bytes (ptr+len+cap)
}

use std::mem::{size_of, align_of};

#[derive(Debug)]
struct Example {
    a: bool,
    b: i32,
    c: u8,
    d: i64,
}

fn main() {
    println!("Size:  {}", size_of::<Example>());  // 16
    println!("Align: {}", align_of::<Example>()); // 8

    // Verify with repr(C)
    #[repr(C)]
    struct ExampleC { a: bool, b: i32, c: u8, d: i64 }
    println!("C Size: {}", size_of::<ExampleC>()); // 24 (C rules — stricter padding)

    // Check common types
    println!("bool:    size={} align={}", size_of::<bool>(), align_of::<bool>());
    println!("char:    size={} align={}", size_of::<char>(), align_of::<char>());
    println!("String:  size={} align={}", size_of::<String>(), align_of::<String>());
    println!("Vec<u8>: size={} align={}", size_of::<Vec<u8>>(), align_of::<Vec<u8>>());
    println!("&str:    size={} align={}", size_of::<&str>(), align_of::<&str>());
}

// ✅ Use repr(C) for all shared structs
#[repr(C)]
pub struct Config { ... }

// ✅ Use repr(transparent) for newtype wrappers at FFI boundary
#[repr(transparent)]
pub struct Handle(u64);

// ✅ Use C-compatible types only (no String, Vec, references)
#[repr(C)]
pub struct CConfig {
    pub name: *const std::os::raw::c_char, // not String
    pub values: *const i32,                // not Vec<i32>
    pub values_len: usize,
    pub timeout_ms: u32,
}

// ✅ Export with C calling convention
#[no_mangle]
pub extern "C" fn process_config(config: *const CConfig) -> i32 {
    if config.is_null() { return -1; }
    let config = unsafe { &*config };
    // ...
    0
}

// ✅ Document who allocates and frees memory
/// Caller must free the returned pointer with `free_result()`
#[no_mangle]
pub extern "C" fn create_result() -> *mut CResult {
    Box::into_raw(Box::new(CResult { ... }))
}

#[no_mangle]
pub extern "C" fn free_result(ptr: *mut CResult) {
    if !ptr.is_null() {
        unsafe { drop(Box::from_raw(ptr)); }
    }
}