posixmemory.h

Go to the documentation of this file.

#pragma once
#include <algorithm>
#include <type_traits>
#ifndef MEMORY_POSIXMEMORY_H
#define MEMORY_POSIXMEMORY_H
//------------------------------------------------------------------------------
#include "core/config.h"
#include "core/debug.h"
#include "threading/interlocked.h"
#include "memory/posix/posixmemoryconfig.h"
#include <string.h>
#include <sys/mman.h>
 
namespace Memory
{
#if NEBULA_MEMORY_STATS
extern int volatile TotalAllocCount;
extern size_t volatile TotalAllocSize;
extern int volatile HeapTypeAllocCount[NumHeapTypes];
extern size_t volatile HeapTypeAllocSize[NumHeapTypes];
#endif
 
#define StackAlloc(size) alloca(size);
#define StackFree(ptr)
 
#if __APPLE__
#define explicit_bzero bzero;
#endif
 
//------------------------------------------------------------------------------
__forceinline void*
Alloc(HeapType heapType, size_t size, size_t align = 16)
{
    n_assert(heapType < NumHeapTypes);
    n_assert(align != 0);
    void* allocPtr = 0;
    {
        align = std::max(align, sizeof(void*));
 
        #if NEBULA_DEBUG
        // Posix requirements state that alignment must be a
        // multiple of sizeof(void*).
        n_assert((align & (align - 1)) == 0);
        #endif
        int err = posix_memalign(&allocPtr, align, size);
        n_assert(err == 0);
        #if NEBULA_DEBUG
        explicit_bzero(allocPtr,size);
        #endif
    }
    #if NEBULA_MEMORY_STATS
        SIZE_T s = HeapSize(Heaps[heapType], 0, allocPtr);
        Threading::Interlocked::Increment(TotalAllocCount);
        Threading::Interlocked::Add(TotalAllocSize, int(s));
        Threading::Interlocked::Increment(HeapTypeAllocCount[heapType]);
        Threading::Interlocked::Add(HeapTypeAllocSize[heapType], int(s));
    #endif
    return allocPtr;
}
 
//------------------------------------------------------------------------------
__forceinline void*
Realloc(HeapType heapType, void* ptr, size_t size)
{
    n_assert(heapType < NumHeapTypes);
    #if NEBULA_MEMORY_STATS
        SIZE_T oldSize = HeapSize(Heaps[heapType], 0, ptr);
    #endif
    void* allocPtr = realloc(ptr, size);
    #if NEBULA_MEMORY_STATS
        SIZE_T newSize = HeapSize(Heaps[heapType], 0, allocPtr);
        Threading::Interlocked::Add(TotalAllocSize, int(newSize - oldSize));
        Threading::Interlocked::Add(HeapTypeAllocSize[heapType], int(newSize - oldSize));
    #endif
    return allocPtr;
}
 
//------------------------------------------------------------------------------
__forceinline void
Free(HeapType heapType, void* ptr)
{
    // D3DX on the 360 likes to call the delete operator with a 0 pointer
    if (0 != ptr)
    {
        n_assert(heapType < NumHeapTypes);
        #if NEBULA_MEMORY_STATS
            SIZE_T size = 0;
        #endif    
        {
            #if NEBULA_MEMORY_STATS
                size = HeapSize(Heaps[heapType], 0, ptr);
            #endif
            free(ptr);
        }
        #if NEBULA_MEMORY_STATS
            Threading::Interlocked::Add(TotalAllocSize, -int(size));
            Threading::Interlocked::Decrement(TotalAllocCount);
            Threading::Interlocked::Add(HeapTypeAllocSize[heapType], -int(size));
            Threading::Interlocked::Decrement(HeapTypeAllocCount[heapType]);
        #endif
    }
}
 
//------------------------------------------------------------------------------
__forceinline void*
AllocVirtual(size_t size)
{
    void* ret = mmap(nullptr, size, PROT_NONE, MAP_ANON | MAP_PRIVATE, 0, 0);
    n_assert(ret != nullptr);
    return ret;
}
 
//------------------------------------------------------------------------------
__forceinline void 
DecommitVirtual(void* ptr, size_t size)
{
    auto ret = madvise(ptr, size, MADV_DONTNEED);
    n_assert(ret == 0);
    ret = mprotect(ptr, size, PROT_NONE);
    n_assert(ret == 0);
}
 
//------------------------------------------------------------------------------
__forceinline void
CommitVirtual(void* ptr, size_t size)
{
    auto ret = mprotect(ptr, size, PROT_READ | PROT_WRITE);
    explicit_bzero(ptr, size);
    n_assert(ret == 0);
}
 
//------------------------------------------------------------------------------
__forceinline void
FreeVirtual(void* ptr, size_t size)
{
    auto ret = madvise(ptr, size, MADV_DONTNEED);
    n_assert(ret == 0);
    ret = munmap(ptr, size);
    n_assert(ret == 0);
}
 
//------------------------------------------------------------------------------
__forceinline void
Copy(const void* from, void* to, size_t numBytes)
{
    if (numBytes > 0)
    {
        n_assert(0 != from);
        n_assert(0 != to);
        n_assert(from != to);
        memcpy(to, from, numBytes);
    }
}
 
//------------------------------------------------------------------------------
__forceinline void
Move(const void* from, void* to, size_t numBytes)
{
    if (numBytes > 0)
    {
        n_assert(0 != from);
        n_assert(0 != to);
        n_assert(from != to);
        memmove(to, from, numBytes);
    }
}
 
//------------------------------------------------------------------------------
template <typename T>
__forceinline void
MoveElements(const T* from, T* to, size_t numElements)
{
    if (numElements > 0)
    {
        n_assert(0 != from);
        n_assert(0 != to);
        n_assert(from != to);
        if constexpr (std::is_trivially_move_assignable<T>::value && std::is_trivially_move_constructible<T>::value)
        {
            memmove((void*)to, (const void*)from, numElements * sizeof(T));
        }
        else
        {
            std::move(from, from + numElements, to);
        }
    }
}
 
//------------------------------------------------------------------------------
template <typename T>
__forceinline void
CopyElements(const T* from, T* to, size_t numElements)
{
    if (numElements > 0)
    {
        n_assert(0 != from);
        n_assert(0 != to);
        n_assert(from != to);
        if constexpr (std::is_trivially_copyable<T>::value)
        {
            memcpy(to, from, numElements * sizeof(T));
        }
        else
        {
            std::copy(from, from + numElements, to);
        }
    }
}
 
//------------------------------------------------------------------------------
__forceinline void
CopyToGraphicsMemory(const void* from, void* to, size_t numBytes)
{
    // no special handling on the Win32 platform
    Memory::Copy(from, to, numBytes);
}
 
//------------------------------------------------------------------------------
__forceinline void
Clear(void* ptr, size_t numBytes)
{
    memset(ptr, 0, numBytes);
}
 
//------------------------------------------------------------------------------
__forceinline void
Fill(void* ptr, size_t numBytes, unsigned char value)
{
    memset(ptr, value, numBytes);
}
 
//------------------------------------------------------------------------------
__forceinline char*
DuplicateCString(const char* from)
{
    n_assert(0 != from);
    size_t len = (unsigned int) strlen(from) + 1;
    char* to = (char*) Memory::Alloc(Memory::StringDataHeap, len);
    Memory::Copy((void*)from, to, len);
    return to;
}
 
//------------------------------------------------------------------------------
inline bool
IsOverlapping(const unsigned char* srcPtr, size_t srcSize, const unsigned char* dstPtr, size_t dstSize)
{
    if (srcPtr == dstPtr)
    {
        return true;
    }
    else if (srcPtr > dstPtr)
    {
        return (srcPtr + srcSize) > dstPtr;
    }
    else
    {
        return (dstPtr + dstSize) > srcPtr;
    }
}
 
//------------------------------------------------------------------------------
struct TotalMemoryStatus
{
    unsigned int totalPhysical;
    unsigned int availPhysical;
    unsigned int totalVirtual;
    unsigned int availVirtual;
};
 
inline TotalMemoryStatus
GetTotalMemoryStatus()
{
#if 0
    MEMORYSTATUS stats = { NULL };
    GlobalMemoryStatus(&stats);
    TotalMemoryStatus result;
    result.totalPhysical = (unsigned int) stats.dwTotalPhys;
    result.availPhysical = (unsigned int) stats.dwAvailPhys;
    result.totalVirtual  = (unsigned int) stats.dwTotalVirtual;
    result.availVirtual  = (unsigned int) stats.dwAvailVirtual;
    return result;
#else
    TotalMemoryStatus result;
    return result;
#endif
}
 
//------------------------------------------------------------------------------
#if NEBULA_MEMORY_STATS
extern bool Validate();
#endif
 
} // namespace Memory
//------------------------------------------------------------------------------
#endif