Memory Bugs, Alignment & Struct Padding

#include <cstddef>
#include <cstdint>
#include <iostream>
#include <string>

// 1. Poorly ordered struct: 12 bytes (6 bytes wasted in padding)
struct UnoptimizedData {
    char a;   // 1 byte  @ offset 0
    // [PAD]: 3 bytes padding (int requires offset multiple of 4)
    int b;    // 4 bytes @ offset 4
    char c;   // 1 byte  @ offset 8
    // [PAD]: 3 bytes tail padding (sizeof must be multiple of alignof = 4)
}; // sizeof == 12, alignof == 4

// 2. Optimally ordered struct: 8 bytes (0 wasted bytes)
struct OptimizedData {
    int b;    // 4 bytes @ offset 0
    char a;   // 1 byte  @ offset 4
    char c;   // 1 byte  @ offset 5
    // [PAD]: 2 bytes tail padding (sizeof multiple of 4)
}; // sizeof == 8, alignof == 4

// 3. The Dangling Stack Reference Trap vs Safe Return
// const std::string& getBadDangling() {
//     std::string s = "Dangling local string";
//     return s; // BUG: Dangling reference to popped stack frame!
// }

std::string getSafeString() {
    std::string s = "Safe return by value (RVO/move)";
    return s; // Guaranteed safe via Return Value Optimization (C++17)
}

int main() {
    std::cout << "--- Struct Alignment & Padding Analysis ---\n";
    std::cout << "UnoptimizedData sizeof: " << sizeof(UnoptimizedData)
              << ", alignof: " << alignof(UnoptimizedData) << '\n';
    std::cout << "OptimizedData sizeof:   " << sizeof(OptimizedData)
              << ", alignof: " << alignof(OptimizedData) << '\n';

    UnoptimizedData u{'X', 42, 'Z'};
    OptimizedData o{42, 'X', 'Z'};
    std::cout << "UnoptimizedData: a=" << u.a << ", b=" << u.b << ", c=" << u.c << '\n';
    std::cout << "OptimizedData:   b=" << o.b << ", a=" << o.a << ", c=" << o.c << '\n';

    std::cout << "\n--- Safe Value Return (RVO) ---\n";
    std::string message = getSafeString();
    std::cout << "Result: " << message << '\n';

    return 0;
}

#include <cstddef>
#include <cstdint>
#include <print>

// ============================================================================
// 1. HARDWARE MEMORY ALIGNMENT & STRUCT PADDING
// Hardware rule: CPUs read memory in 4-byte, 8-byte, or 64-byte word boundaries.
// An 8-byte uint64_t MUST start at an address divisible by 8 (addr % 8 == 0).
// If unaligned, the CPU pays a 2x-3x memory bus penalty or generates a hardware fault.
// To satisfy alignment, compilers inject invisible "padding bytes".
// ============================================================================

// Case 1: Naive struct layout with scattered types (Severe Padding Waste)
struct BloatedPacket {
    uint8_t flags;       // 1 byte  (offset 0)
    // Compiler injects 7 PADDING BYTES here so 'timestamp' lands on offset 8!
    uint64_t timestamp;  // 8 bytes (offset 8)
    uint16_t id;         // 2 bytes (offset 16)
    // Compiler injects 2 PADDING BYTES here so 'checksum' lands on offset 20!
    uint32_t checksum;   // 4 bytes (offset 20)
    uint8_t priority;    // 1 byte  (offset 24)
    // Compiler injects 7 TAIL PADDING BYTES so sizeof is a multiple of alignof = 8!
}; // Total size: 32 BYTES! 16 bytes useful data + 16 bytes wasted padding (50% waste).

// Case 2: Optimal struct ordering (Sort members from largest alignment to smallest)
struct CompactPacket {
    uint64_t timestamp;  // 8 bytes (offset 0)
    uint32_t checksum;   // 4 bytes (offset 8)
    uint16_t id;         // 2 bytes (offset 12)
    uint8_t flags;       // 1 byte  (offset 14)
    uint8_t priority;    // 1 byte  (offset 15)
    // ZERO padding bytes needed! All alignments naturally satisfied.
}; // Total size: 16 BYTES! (100% useful data, halves cache usage and memory bandwidth).

// ============================================================================
// 2. CACHE LINE FALSE SHARING
// When multiple CPU cores write to independent variables located in the SAME
// 64-byte L1 cache line, the CPU cache coherency protocol (MESI) constantly
// invalidates and reloads the line across cores, causing a 10x-50x slowdown!
// ============================================================================

// Buggy: Both counters land within the same 64-byte cache line
struct FalseSharingCounters {
    uint64_t threadA_counter; // 8 bytes (offset 0)
    uint64_t threadB_counter; // 8 bytes (offset 8) — SAME 64-byte cache line!
};

// Fixed: alignas(64) forces each variable onto its own dedicated 64-byte L1 cache line
struct AlignedCounters {
    alignas(64) uint64_t threadA_counter; // 8 bytes (offset 0, cache line 0)
    alignas(64) uint64_t threadB_counter; // 8 bytes (offset 64, cache line 1)
};

int main() {
    std::println("--- Struct Padding & Memory Alignment ---");
    std::println("BloatedPacket: sizeof = {} bytes, alignof = {}",
                 sizeof(BloatedPacket), alignof(BloatedPacket));
    std::println("  offsets: flags={}, timestamp={}, id={}, checksum={}, priority={}",
                 offsetof(BloatedPacket, flags),
                 offsetof(BloatedPacket, timestamp),
                 offsetof(BloatedPacket, id),
                 offsetof(BloatedPacket, checksum),
                 offsetof(BloatedPacket, priority));

    std::println("CompactPacket: sizeof = {} bytes, alignof = {}",
                 sizeof(CompactPacket), alignof(CompactPacket));
    std::println("  offsets: timestamp={}, checksum={}, id={}, flags={}, priority={}",
                 offsetof(CompactPacket, timestamp),
                 offsetof(CompactPacket, checksum),
                 offsetof(CompactPacket, id),
                 offsetof(CompactPacket, flags),
                 offsetof(CompactPacket, priority));

    std::size_t savedBytes = sizeof(BloatedPacket) - sizeof(CompactPacket);
    std::size_t percent = (savedBytes * 100) / sizeof(BloatedPacket);
    std::println("Memory savings: {} bytes per packet ({}% reduction)", savedBytes, percent);

    std::println("--- Cache-Line False Sharing Prevention ---");
    std::println("FalseSharingCounters: sizeof = {} bytes, offset delta = {} bytes",
                 sizeof(FalseSharingCounters),
                 offsetof(FalseSharingCounters, threadB_counter) - offsetof(FalseSharingCounters, threadA_counter));
    std::println("AlignedCounters: sizeof = {} bytes, offset delta = {} bytes (>= 64B cache line)",
                 sizeof(AlignedCounters),
                 offsetof(AlignedCounters, threadB_counter) - offsetof(AlignedCounters, threadA_counter));

    return 0;
}