Ytukyg

I was reading a book about making a game engine because I want to create my own and in the book it suggests writing your own custom allocator so I went off of what the book described and made a double-ended stack-based allocator. The book also mentioned that all allocators should be able to allocate memory aligned. I'm having a little trouble understanding why the book implemented aligning the way they did. In the book there is a function which takes in the size of the amount you want to allocate, and a size for alignment. It says the alignment should only ever be a power of 2 which is where I start to not get it and it also makes sure it can't be greater then 128. My question is why? I have a class called Sprite and sizeof(Sprite) = 136. Let's say that I want to make a struct with one Sprite and an int. What would the alignment be because sizeof(Sprite) is 136 and sizeof(int) is 4. What should I put in alignment for this situation? How do I use this method?

EDIT:
I read Purpose of memory alignment and the answers there didn't help me at all. I understand the purpose of memory alignment and how a 32bit memory should be 4 byte aligned. I also know that 4 byte aligned memory reside on addresses with nibbles at multiples of 4 (ie 0x0, 0x4, 0x8, or 0xC). I just don't understand what happens when I have memory that is 136 bytes (as is the case with my Sprite class) that's in the same struct as a 4 byte int. I also want to know why the method requires alignment to be a power of 2 and less than 128.

Here is the code for aligning:

// Allocate memory in an efficient way which means aligning it

// IMPORTANT: the alignment must be a power of 2 (usually 4 or 16)

void* DESA::allocAligned(size_t size_bytes, size_t alignment, unsigned int flag) {

    assert(flag == LEFT | flag == RIGHT);



    assert(alignment >= 1);

    assert(alignment <= 128);

    assert((alignment & (alignment - 1)) == 0); // Make sure it's a power of 2



    // Total amount of bytes

    size_t expandedSize_bytes = size_bytes + alignment;



    // Allocate unaligned memory and convert to uintptr_t

    // allocUnaligned just increments a pointer

    std::uintptr_t rawAddress;

    if (flag == LEFT)

        rawAddress = reinterpret_cast<std::uintptr_t>(allocUnaligned(expandedSize_bytes, LEFT));

    else if (flag == RIGHT)

        rawAddress = reinterpret_cast<std::uintptr_t>(allocUnaligned(expandedSize_bytes, RIGHT));



    // Calculate misalignment

    size_t mask = alignment - 1;

    std::uintptr_t misalignment = rawAddress & mask;

    std::ptrdiff_t adjustment = alignment - misalignment;



    // Calculate the adjusted address

    std::uintptr_t alignedAddress = rawAddress + adjustment;



    // Store the adjustment in the byte immediately preceding the adjusted address

    assert(adjustment < 256);

    U8* pAlignedMem = reinterpret_cast<U8*>(alignedAddress);

    pAlignedMem[-1] = static_cast<U8>(adjustment);



    return static_cast<void*>(pAlignedMem);

}