vl_memory.h

Go to the documentation of this file.

 
#ifndef VL_MEMORY_H
#define VL_MEMORY_H
 
#include <malloc.h>
 
#include "vl_compare.h"
#include "vl_numtypes.h"
 
typedef VL_MEMORY_SIZE_T vl_memsize_t;
 
#ifndef VL_KB
#define VL_KB(x) ((vl_memsize_t)(x) << 10)
#endif
 
#ifndef VL_MB
#define VL_MB(x) ((vl_memsize_t)(x) << 20)
#endif
 
#ifndef VL_DEFAULT_MEMORY_SIZE
#define VL_DEFAULT_MEMORY_SIZE VL_KB(1)
#endif
 
#ifndef VL_DEFAULT_MEMORY_ALIGN
 
#ifdef _MSC_VER
#define VL_ALIGNOF(T) __alignof(T)
#else
#define VL_ALIGNOF(T) __alignof__(T)
#endif
 
#define VL_DEFAULT_MEMORY_ALIGN VL_ALIGNOF(vl_ularge_t)
#endif
 
#ifndef VL_MEMORY_PAD_UP
#define VL_MEMORY_PAD_UP(len, pad) (((len) + (pad) - 1) & ~((pad) - 1))
#endif
 
#ifndef VL_ALIGN_HINT
#if defined(_MSC_VER)
#define VL_ALIGN_HINT(x) __declspec(align(x))
#elif defined(__GNUC__) || defined(__clang__)
#define VL_ALIGN_HINT(x) __attribute__((aligned(x)))
#else
#define VL_ALIGN_HINT(x)
#warning VL_ALIGN_HINT failed to resolve. Structure alignment is not guaranteed.
#endif
#endif
 
typedef VL_MEMORY_T vl_memory;
 
typedef VL_MEMORY_T vl_transient;
 
VL_API vl_memory* vlMemAlloc(vl_memsize_t allocSize);
 
VL_API vl_memory* vlMemRealloc(vl_memory* mem, vl_memsize_t allocSize);
 
VL_API vl_memory* vlMemAllocAligned(vl_memsize_t allocSize, vl_uint_t align);
 
#define vlMemAllocType(element_type) ((element_type*)vlMemAllocAligned(sizeof(element_type), VL_ALIGNOF(element_type)))
 
#define vlMemAllocTypeArray(element_type, count)                                                                       \
    ((element_type*)vlMemAllocAligned(sizeof(element_type) * (count), VL_ALIGNOF(element_type)))
 
inline vl_transient* vlMemAllocStack(vl_memsize_t allocSize)
{
#ifdef _MSC_VER
    return (vl_transient*)_alloca(allocSize);
#elif defined(__GNUC__) || defined(__clang__)
    return (vl_transient*)__builtin_alloca(allocSize);
#else
#error Failed to resolve stack allocation method.
#endif
}
 
inline vl_transient* vlMemAllocStackAligned(vl_memsize_t allocSize, vl_uint16_t align)
{
    return (vl_transient*)(((vl_uintptr_t)vlMemAllocStack((allocSize) + (align)-1) + (align)-1) & ~((align)-1));
}
 
#define vlMemAllocStackType(element_type)                                                                              \
    ((element_type*)vlMemAllocStackAligned(sizeof(element_type), VL_ALIGNOF(element_type)))
 
#define vlMemAllocStackTypeArray(element_type, count)                                                                  \
    ((element_type*)vlMemAllocStackAligned((count) * sizeof(element_type), VL_ALIGNOF(element_type)))
 
VL_API vl_memory* vlMemClone(vl_memory* mem);
 
VL_API vl_memsize_t vlMemSize(vl_memory* mem);
 
VL_API vl_uint_t vlMemAlignment(vl_memory* mem);
 
VL_API void vlMemSort(void* buffer, vl_memsize_t elementSize, vl_dsidx_t numElements, vl_compare_function comparator);
 
VL_API void vlMemCopyStride(const void* src, vl_dsoffs_t srcStride, void* dest, vl_dsoffs_t dstStride,
                            vl_memsize_t elementSize, vl_dsidx_t numElements);
 
VL_API void vlMemReverseSubArraysStride(void* src, vl_dsoffs_t srcStride, vl_memsize_t elementSize,
                                        vl_dsidx_t numElements);
 
#ifndef vlMemReverse
#define vlMemReverse(src, numBytes) vlMemReverseSubArraysStride(src, 1, numBytes, 1)
#endif
 
#ifndef vlMemReverseSubArrays
#define vlMemReverseSubArrays(src, elementSize, numElements)                                                           \
    vlMemReverseSubArraysStride(src, elementSize, elementSize, numElements)
#endif
 
VL_API void vlMemFree(vl_memory* mem);
 
#endif // VL_MEMORY_H