vn/code/core/core_memory.cpp

////////////////////////////////
//- sixten: Common Memory Functions

static void Copy(void *Dest, void *Source, umm Count)
{
    if(Count <= S64_Max)
    {
        u8 *Dest8 = (u8 *)Dest;
        u8 *Source8 = (u8 *)Source;
        
        while(Count--)
        {
            *Dest8++ = *Source8++;
        }
    }
}

static void CopyReverse(void *Dest, void *Source, umm Count)
{
    if(Count <= S64_Max)
    {
        u8 *Dest8 = (u8 *)Dest + Count;
        u8 *Source8 = (u8 *)Source + Count;
        
        while(Count--)
        {
            *--Dest8 = *--Source8;
        }
    }
}

static void Fill(void *Dest, u8 Value, umm Count)
{
    if(Count <= S64_Max)
    {
        u8 *Dest8 = (u8 *)Dest;
        
        while(Count--)
        {
            *Dest8++ = Value;
        }
    }
}

#if VN_ASAN_ENABLED
#include <sanitizer/asan_interface.h>
#endif

////////////////////////////////
//- sixten: Memory Arena Functions

static arena *ArenaAlloc(u64 Size, b32 Chaining)
{
    arena *Arena = 0;
    if(Chaining)
    {
        void *Memory = Platform.Allocate(Size);
        Arena = (arena *)Memory;
        
#if VN_ASAN_ENABLED
        ASAN_POISON_MEMORY_REGION(Arena, Size);
        ASAN_UNPOISON_MEMORY_REGION(Arena, sizeof(arena));
#endif
        
        Arena->Chaining = true;
        SenDLLInit(Arena);
        
    }
    else
    {
        u64 RoundedSize = Size+Megabytes(64)-1;
        RoundedSize -= RoundedSize&Megabytes(64);
        void *Memory = Platform.Reserve(RoundedSize);
        u64 InitialCommitSize = MEMORY_ARENA_COMMIT_SIZE;
        Platform.Commit(Memory, InitialCommitSize);
        Arena = (arena *)Memory;
    }
    Arena->Position = sizeof(arena);
    Arena->Size = Size;
    Arena->Align = 8;
    return(Arena);
}

static void ArenaRelease(arena *Arena)
{
    if(Arena->Chaining)
    {
        arena *Node = Arena->Prev;
        for(;Node != Arena;)
        {
            arena *Next = Node->Prev;
            Platform.Deallocate(Node);
            Node = Next;
        }
#if VN_ASAN_ENABLED
        ASAN_POISON_MEMORY_REGION(Arena, Arena->Size);
#endif
        Platform.Deallocate(Arena);
    }
    else
    {
        Platform.Release(Arena);
    }
}

static void *ArenaPushNoClear(arena *Arena, u64 Size)
{
    void *Result = 0;
    if(Arena->Chaining)
    {
        if(Size <= Arena->Size)
        {
            arena *Target = Arena->Prev; // sixten: We always append to the end of the list.
            if(Target->Position + Size > Target->Size)
            {
                arena *New = ArenaAlloc(Arena->Size, true);
                New->NotFirst = true;
                SenDLLInsertLast(Arena, New);
                Target = New;
            }
            u8 *Base = (u8 *)Target;
            u64 PostAlignPos = (Target->Position+Target->Align-1);
            PostAlignPos -= PostAlignPos%Target->Align;
            Result = Base + PostAlignPos;
            Target->Position = PostAlignPos+Size;
            
#if VN_ASAN_ENABLED
            ASAN_UNPOISON_MEMORY_REGION(Result, Size);
#endif
        }
        else
        {
            // sixten(NOTE): We can't really do anything in this situation.
        }
    }
    else
    {
        if(Arena->Position + Size <= Arena->Size)
        {
            u8 *Base = (u8 *)Arena;
            u64 PostAlignPos = (Arena->Position+Arena->Align-1);
            PostAlignPos -= PostAlignPos%Arena->Align;
            u64 Align = PostAlignPos - Arena->Position;
            Result = Base + Arena->Position + Align;
            Arena->Position += Size + Align;
            if(Arena->CommitPosition < Arena->Position)
            {
                u64 ToCommit = Arena->Position - Arena->CommitPosition;
                ToCommit += MEMORY_ARENA_COMMIT_SIZE - 1;
                ToCommit -= ToCommit%MEMORY_ARENA_COMMIT_SIZE;
                Platform.Commit(Base + Arena->CommitPosition, ToCommit);
                Arena->CommitPosition += ToCommit;
            }
        }
        else
        {
            InvalidCodepath;
        }
    }
    return(Result);
}

static void *ArenaPush(arena *Arena, u64 Size)
{
    void *Result = ArenaPushNoClear(Arena, Size);
    Fill(Result, 0, Size);
    return(Result);
}

static void ArenaPopTo(arena *Arena, u64 Position)
{
    if(Arena->Chaining)
    {
        // sixten: find the relevant arena
        arena *Target = Arena;
        for(int ArenaIndex = 0; ArenaIndex < Position/Arena->Size; ++ArenaIndex)
        {
            Target = Arena->Next;
        }
        
        // sixten: deallocate all arenas that are no longer needed
        {
            arena *Node = Arena->Prev;
            while(Node != Target)
            {
                arena *Prev = Node->Prev;
                SenDLLRemove(Node);
#if VN_ASAN_ENABLED
                ASAN_POISON_MEMORY_REGION(Node, Node->Size);
#endif
                Platform.Deallocate(Node);
                Node = Prev;
            }
        }
        
        Target->Position = Position%Arena->Size;
#if VN_ASAN_ENABLED
        u64 UnpoisonPosition = Target->Position;
        ASAN_POISON_MEMORY_REGION(Target, Target->Size);
        ASAN_UNPOISON_MEMORY_REGION(Target, UnpoisonPosition);
#endif
    }
    else
    {
        u64 MinPosition = sizeof(*Arena);
        u64 NewPosition = Maximum(MinPosition, Position);
        Arena->Position = NewPosition;
        u64 CommitAlignedPosition = Arena->Position+MEMORY_ARENA_COMMIT_SIZE-1;
        CommitAlignedPosition -= CommitAlignedPosition%MEMORY_ARENA_COMMIT_SIZE;
        if(CommitAlignedPosition + MEMORY_ARENA_DECOMMIT_THRESHOLD <= Arena->CommitPosition)
        {
            u8 *Base = (u8 *)Arena;
            u64 ToDecommit = Arena->CommitPosition-CommitAlignedPosition;
            Platform.Decommit(Base+CommitAlignedPosition, ToDecommit);
            Arena->CommitPosition -= ToDecommit;
        }
    }
}

static void ArenaPop(arena *Arena, u64 Amount)
{
    ArenaPopTo(Arena, Max(Arena->Position-Amount, (s64)sizeof(arena)));
}

static void ArenaClear(arena *Arena)
{
    ArenaPopTo(Arena, sizeof(*Arena));
}

static void ArenaSetAlign(arena *Arena, u64 Align)
{
    Arena->Align = Align;
}

////////////////////////////////
//- sixten: Temporary Memory Functions

static temporary_memory BeginTemporaryMemory(arena *Arena)
{
    temporary_memory Temp;
    Temp.Arena = Arena;
    Temp.Position = Arena->Position;
    return(Temp);
}

static void EndTemporaryMemory(temporary_memory Temp)
{
    ArenaPopTo(Temp.Arena, Temp.Position);
}