kmemory.h

Go to the documentation of this file.

 
#pragma once
 
#include "defines.h"
 
// Turn on for per-allocation verification of memory. Has both a performance and memory impact,
// so only leave on when troubleshooting.
#define MEM_DEBUG_TRACE 1
 
// Interface for a frame allocator.
typedef struct frame_allocator_int {
    void* (*allocate)(u64 size);
    void (*free)(void* block, u64 size);
    void (*free_all)(void);
    u64 (*total_space)(void);
    u64 (*allocated)(void);
} frame_allocator_int;
 
typedef enum memory_tag {
    // For temporary use. Should be assigned one of the below or have a new tag created.
    MEMORY_TAG_UNKNOWN,
    MEMORY_TAG_ARRAY,
    MEMORY_TAG_LINEAR_ALLOCATOR,
    MEMORY_TAG_POOL_ALLOCATOR,
    MEMORY_TAG_DARRAY,
    MEMORY_TAG_DICT,
    MEMORY_TAG_RING_QUEUE,
    MEMORY_TAG_BST,
    MEMORY_TAG_STRING,
    MEMORY_TAG_ENGINE,
    MEMORY_TAG_JOB,
    MEMORY_TAG_TEXTURE,
    MEMORY_TAG_MATERIAL_INSTANCE,
    MEMORY_TAG_RENDERER,
    MEMORY_TAG_GAME,
    MEMORY_TAG_TRANSFORM,
    MEMORY_TAG_BINARY_STRING_TABLE,
    MEMORY_TAG_BINARY_DATA,
    MEMORY_TAG_SCENE,
    MEMORY_TAG_PACKAGE,
    MEMORY_TAG_VULKAN,
    // "External" vulkan allocations, for reporting purposes only.
    MEMORY_TAG_VULKAN_EXT,
    MEMORY_TAG_DIRECT3D,
    MEMORY_TAG_OPENGL,
    // Representation of GPU-local/vram
    MEMORY_TAG_GPU_LOCAL,
    MEMORY_TAG_BITMAP_FONT,
    MEMORY_TAG_SYSTEM_FONT,
    MEMORY_TAG_KEYMAP,
    MEMORY_TAG_HASHTABLE,
    MEMORY_TAG_UI,
    MEMORY_TAG_AUDIO,
    MEMORY_TAG_REGISTRY,
    MEMORY_TAG_PLUGIN,
    MEMORY_TAG_PLATFORM,
    MEMORY_TAG_SERIALIZER,
    MEMORY_TAG_ASSET,
    MEMORY_TAG_EDITOR,
 
    MEMORY_TAG_MAX_TAGS
} memory_tag;
 
typedef struct memory_system_configuration {
    u64 total_alloc_size;
} memory_system_configuration;
 
KAPI b8 memory_system_initialize(memory_system_configuration config);
 
KAPI void memory_system_shutdown(void);
 
KAPI void* _kallocate(u64 size, memory_tag tag, const char* file, u32 line);
 
#define kallocate(size, tag) _kallocate(size, tag, __FILE__, __LINE__)
 
#define KALLOC_TYPE(type, mem_tag) (type*)kallocate(sizeof(type), mem_tag)
 
#define KFREE_TYPE(block, type, mem_tag) kfree(block, sizeof(type), mem_tag)
 
#define KALLOC_TYPE_CARRAY(type, count) (type*)kallocate(sizeof(type) * count, MEMORY_TAG_ARRAY)
 
#define KFREE_TYPE_CARRAY(block, type, count)                 \
    if (block) {                                              \
        kfree(block, sizeof(type) * count, MEMORY_TAG_ARRAY); \
    }
 
#define KRESIZE_ARRAY(array, type, old_count, new_count)     \
    {                                                        \
        type* temp = KALLOC_TYPE_CARRAY(type, new_count);    \
        if (old_count && array) {                            \
            KCOPY_TYPE_CARRAY(temp, array, type, old_count); \
            KFREE_TYPE_CARRAY(array, type, old_count);       \
        }                                                    \
        array = temp;                                        \
    }
 
KAPI void* _kallocate_aligned(u64 size, u16 alignment, memory_tag tag, const char* filename, u32 line);
 
#define kallocate_aligned(size, alignment, tag) _kallocate_aligned(size, alignment, tag, __FILE__, __LINE__)
 
KAPI void kallocate_report(u64 size, memory_tag tag);
 
KAPI void* _kreallocate(void* block, u64 old_size, u64 new_size, memory_tag tag, const char* filename, u32 line);
 
#define kreallocate(block, old_size, new_size, tag) _kreallocate(block, old_size, new_size, tag, __FILE__, __LINE__)
 
#define KREALLOC_TYPE_CARRAY(block, type, old_count, new_count) (type*)kreallocate(block, sizeof(type) * (old_count), sizeof(type) * (new_count), MEMORY_TAG_ARRAY)
 
KAPI void* _kreallocate_aligned(void* block, u64 old_size, u64 new_size, u16 alignment, memory_tag tag, const char* filename, u32 line);
 
#define kreallocate_aligned(block, old_size, new_size, alignment, tag) _kreallocate_aligned(block, old_size, new_size, alignment, tag, __FILE__, __LINE__)
 
KAPI void kreallocate_report(u64 old_size, u64 new_size, memory_tag tag);
 
KAPI void kfree(void* block, u64 size, memory_tag tag);
 
KAPI void kfree_aligned(void* block, u64 size, u16 alignment, memory_tag tag);
 
KAPI void kfree_report(u64 size, memory_tag tag);
 
KAPI b8 kmemory_get_size_alignment(void* block, u64* out_size, u16* out_alignment, memory_tag* out_tag);
 
KAPI void* kzero_memory(void* block, u64 size);
 
#define KZERO_TYPE(block, type) kzero_memory(block, sizeof(type));
#define KZERO_TYPE_CARRAY(block, type, count) kzero_memory(block, sizeof(type) * count);
 
KAPI void* kcopy_memory(void* dest, const void* source, u64 size);
 
#define KCOPY_TYPE(dest, source, type) kcopy_memory(dest, source, sizeof(type))
#define KCOPY_TYPE_CARRAY(dest, source, type, count) kcopy_memory(dest, source, sizeof(type) * count)
 
#define KDUPLICATE_TYPE_CARRAY(dest, source, type, count) \
    dest = KALLOC_TYPE_CARRAY(type, count);               \
    KCOPY_TYPE_CARRAY(dest, source, type, count);
 
KAPI void* kset_memory(void* dest, i32 value, u64 size);
 
KAPI const char* get_unit_for_size(u64 size_bytes, f32* out_amount);
 
KAPI char* get_memory_usage_str(void);
 
KAPI u64 get_memory_alloc_count(void);
 
KAPI u64 get_total_memory_space(void);
KAPI u64 get_free_memory_space(void);
KAPI u64 get_used_memory_space(void);
 
KAPI u32 pack_u8_into_u32(u8 x, u8 y, u8 z, u8 w);
 
KAPI b8 unpack_u8_from_u32(u32 n, u8* x, u8* y, u8* z, u8* w);