libmemalloc.h

Go to the documentation of this file.

 
#pragma once
 
/*< C++ Compatibility >*/
#ifdef __cplusplus
extern "C"
{
#endif
 
/*< Dependencies >*/
#include <pthread.h>
#include <stdatomic.h>
#include <stdbool.h>
#include <stdint.h>
#include <string.h>
 
#ifndef ARCH_ALIGNMENT
  /* x86_64 processor [64-bit] - Vendor: AMD/Intel */
  #if defined(__x86_64__) || defined(_M_X64) || defined(__amd64__)
    #define ARCH_ALIGNMENT (8U)
 
  /* i386 processor [32-bit] - Vendor: Intel */
  #elif defined(__i386__) || defined(_M_IX86) || defined(__386__)
    #define ARCH_ALIGNMENT (4U)
 
  /* aarch64 processor [64-bit] - Vendor: ARM */
  #elif defined(__aarch64__) || defined(_M_ARM64) || defined(__arm64__)
    #define ARCH_ALIGNMENT (8U)
 
  /* arm processor [32-bit] - Vendor: ARM (v7/v6) */
  #elif defined(__ARM_ARCH_7__) || defined(__ARM_ARCH_6__) || defined(__arm__) \
    || defined(_M_ARM)
    #define ARCH_ALIGNMENT (4U)
 
  /* riscv processor [64-bit] - Vendor: RISC-V */
  #elif defined(__riscv) && (__riscv_xlen == 64)
    #define ARCH_ALIGNMENT (8U)
  /* riscv processor [32-bit] - Vendor: RISC-V */
  #elif defined(__riscv) && (__riscv_xlen == 32)
    #define ARCH_ALIGNMENT (4U)
 
  /* powerpc processor [64-bit] - Vendor: IBM */
  #elif defined(__powerpc64__) || defined(__PPC64__)
    #define ARCH_ALIGNMENT (8U)
  /* powerpc processor [32-bit] - Vendor: IBM */
  #elif defined(__powerpc__) || defined(__PPC__)
    #define ARCH_ALIGNMENT (4U)
 
  /* s390x processor [64-bit] - Vendor: IBM */
  #elif defined(__s390x__) || defined(__s390__)
    #define ARCH_ALIGNMENT (8U)
 
  /* mips processor [64-bit] - Vendor: MIPS */
  #elif defined(__mips64) || defined(__mips64el__)
    #define ARCH_ALIGNMENT (8U)
  /* mips processor [32-bit] - Vendor: MIPS */
  #elif defined(__mips__)
    #define ARCH_ALIGNMENT (4U)
 
  /* loongarch processor [64-bit] - Vendor: Loongson */
  #elif defined(__loongarch__)
    #define ARCH_ALIGNMENT (8U)
 
  /* avr processor [8-bit] - Vendor: Microchip */
  #elif defined(__AVR__)
    #define ARCH_ALIGNMENT (2U)
  /* avr32 processor [32-bit] - Vendor: Microchip */
  #elif defined(__avr32__)
    #define ARCH_ALIGNMENT (4U)
 
  /* microblaze processor [32-bit] - Vendor: Xilinx */
  #elif defined(__MICROBLAZE__)
    #define ARCH_ALIGNMENT (4U)
 
  /* sh processor [32-bit] - Vendor: Renesas */
  #elif defined(__sh__)
    #define ARCH_ALIGNMENT (4U)
 
  /* arc processor [32-bit] - Vendor: Synopsys */
  #elif defined(__arc__)
    #define ARCH_ALIGNMENT (4U)
 
  /* bfin processor [32-bit] - Vendor: Analog Devices */
  #elif defined(__bfin__)
    #define ARCH_ALIGNMENT (4U)
 
  /* wasm processor [32-bit] - Vendor: WebAssembly/Emscripten */
  #elif defined(__EMSCRIPTEN__) || defined(__wasm__)
    #define ARCH_ALIGNMENT (4U)
 
  /* sparc processor [32-bit] - Vendor: Oracle */
  #elif defined(__sparc__) || defined(__sparc)
    #define ARCH_ALIGNMENT (4U)
  /* sparc processor [64-bit] - Vendor: Oracle (V9) */
  #elif defined(__sparcv9__)
    #define ARCH_ALIGNMENT (8U)
 
  /* ia64 processor [64-bit] - Vendor: Intel Itanium */
  #elif defined(__ia64__)
    #define ARCH_ALIGNMENT (8U)
 
  /* alpha processor [64-bit] - Vendor: DEC */
  #elif defined(__alpha__)
    #define ARCH_ALIGNMENT (8U)
 
  /* pru processor [32-bit] - Vendor: TI */
  #elif defined(__TI_PRU__) || defined(__PRU__)
    #define ARCH_ALIGNMENT (4U)
  /* PA-RISC [32-bit] – Vendor: HP PA-RISC */
  #elif defined(__hppa__)
    #define ARCH_ALIGNMENT (4U)
 
  /* z/Arch [64-bit] – Vendor: IBM Z */
  #elif defined(__zarch__)
    #define ARCH_ALIGNMENT (8U)
 
  /* SPU [32-bit] – Vendor: Cell Broadband */
  #elif defined(__cell_spu__)
    #define ARCH_ALIGNMENT (16U) /* SPU natural aligns to 16 bytes */
 
  /* NVPTX [64-bit] – Vendor: NVIDIA PTX */
  #elif defined(__NVPTX__) || defined(__PTX__)
    #define ARCH_ALIGNMENT (8U)
 
  /* eBPF [64-bit] – in-kernel VM */
  #elif defined(__bpf__)
    #define ARCH_ALIGNMENT (8U)
 
  /* Elbrus E2K [64-bit] – Vendor: MCST */
  #elif defined(__e2k__)
    #define ARCH_ALIGNMENT (8U)
 
  /* CRIS [32-bit] – Vendor: Axis Communications */
  #elif defined(__CRIS__)
    #define ARCH_ALIGNMENT (4U)
 
  /* TILEGX [64-bit] – Vendor: Tilera */
  #elif defined(__tilegx__)
    #define ARCH_ALIGNMENT (8U)
 
  /* Generic fallback */
  #else
    #error "[ERROR] Unknow Architecture: check 'ARCH_ALIGNMENT'"
  #endif
#endif
 
#ifndef __ALIGN
  #if defined(__GNUC__) || defined(__clang__)
    #if __BYTE_ORDER__ == __ORDER_BIG_ENDIAN__
      #define __ALIGN                                      \
        __attribute__((scalar_storage_order("big-endian"), \
                       aligned(ARCH_ALIGNMENT)))
    #elif __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__
      #define __ALIGN                                         \
        __attribute__((scalar_storage_order("little-endian"), \
                       aligned(ARCH_ALIGNMENT)))
    #else
      #error "[ERROR] Unknow Endianness: check '__BYTE_ORDER__'"
    #endif
  #else
    #define __ALIGN
  #endif
#endif
 
#if defined(_WIN32)
  #ifdef BUILDING_LIBMEMALLOC
    #define __LIBMEMALLOC_API __declspec(dllexport)
  #else
    #define __LIBMEMALLOC_API __declspec(dllimport)
  #endif
#else
  #if defined(__GNUC__) || defined(__clang__)
    #define __LIBMEMALLOC_API __attribute__((visibility("default")))
  #else
    #define __LIBMEMALLOC_API
  #endif
#endif
 
#if defined(__GNUC__) || defined(__clang__)
  #define __LIBMEMALLOC_MALLOC \
    __attribute__((malloc, alloc_size(2), warn_unused_result))
#else
  #define __LIBMEMALLOC_MALLOC
#endif
 
#if defined(__GNUC__) || defined(__clang__)
  #define __LIBMEMALLOC_REALLOC \
    __attribute__((malloc, alloc_size(3), warn_unused_result))
#else
  #define __LIBMEMALLOC_REALLOC
#endif
 
#define PTR_ERR(x)     ((void *)((intptr_t)(x)))
 
#define ALIGN(x)       (((x) + (ARCH_ALIGNMENT - 1U)) & ~(ARCH_ALIGNMENT - 1U))
 
#define GC_INTERVAL_MS (uint16_t)(100U)
 
typedef enum AllocationStrategy
{
  FIRST_FIT = (uint8_t)(0u), 
  NEXT_FIT  = (uint8_t)(1u), 
  BEST_FIT  = (uint8_t)(2u) 
} allocation_strategy_t;
 
typedef struct __ALIGN BlockHeader
{
  uintptr_t magic; 
  size_t    size;  
  uint32_t free;   
  uint32_t marked; 
  const char *var_name;     
  const char *file;         
  uint64_t    line;         
  uintptr_t canary;         
  struct BlockHeader *next; 
  struct BlockHeader *prev; 
  struct BlockHeader *fl_next; 
  struct BlockHeader
    *fl_prev; 
} block_header_t;
 
typedef struct __ALIGN MemArena
{
  size_t num_bins;            
  block_header_t **bins;      
  block_header_t  *top_chunk; 
} mem_arena_t;
 
typedef struct __ALIGN MmapBlock
{
  void  *addr;            
  size_t size;            
  struct MmapBlock *next; 
} mmap_t;
 
typedef struct __ALIGN GcThread
{
  pthread_t gc_thread;        
  pthread_t main_thread;      
  bool gc_running;            
  bool gc_exit;               
  uint16_t gc_thread_started; 
  uint32_t gc_interval_ms;    
  pthread_cond_t  gc_cond;    
  pthread_mutex_t gc_lock;    
} gc_thread_t;
 
typedef struct __ALIGN MemoryAllocator
{
  uint8_t *heap_start;             
  uint8_t *heap_end;               
  size_t metadata_size;            
  uintptr_t *stack_top;            
  uintptr_t *stack_bottom;         
  size_t num_size_classes;         
  size_t num_arenas;               
  block_header_t  *last_allocated; 
  block_header_t **free_lists;     
  mem_arena_t *arenas;             
  mmap_t      *mmap_list;          
  gc_thread_t gc_thread;           
} mem_allocator_t;
 
__LIBMEMALLOC_API void *MEM_memset(void *const  source,
                                   const int    value,
                                   const size_t size);
 
__LIBMEMALLOC_API void *MEM_memcpy(void *const  dest,
                                   const void  *src,
                                   const size_t size);
 
__LIBMEMALLOC_API int MEM_allocatorInit(mem_allocator_t *const allocator);
 
__LIBMEMALLOC_API void *MEM_allocMallocFirstFit(mem_allocator_t
                                                  *const          allocator,
                                                const size_t      size,
                                                const char *const var)
  __LIBMEMALLOC_MALLOC;
 
__LIBMEMALLOC_API void *MEM_allocMallocBestFit(mem_allocator_t *const allocator,
                                               const size_t           size,
                                               const char *const      var)
  __LIBMEMALLOC_MALLOC;
 
__LIBMEMALLOC_API void *MEM_allocMallocNextFit(mem_allocator_t *const allocator,
                                               const size_t           size,
                                               const char *const      var)
  __LIBMEMALLOC_MALLOC;
 
__LIBMEMALLOC_API void *MEM_allocMalloc(mem_allocator_t *const      allocator,
                                        const size_t                size,
                                        const char *const           var,
                                        const allocation_strategy_t strategy)
  __LIBMEMALLOC_MALLOC;
 
__LIBMEMALLOC_API void *MEM_allocCalloc(mem_allocator_t *const      allocator,
                                        const size_t                size,
                                        const char *const           var,
                                        const allocation_strategy_t strategy)
  __LIBMEMALLOC_MALLOC;
 
__LIBMEMALLOC_API void *MEM_allocRealloc(mem_allocator_t *const      allocator,
                                         void *const                 ptr,
                                         const size_t                new_size,
                                         const char *const           var,
                                         const allocation_strategy_t strategy)
  __LIBMEMALLOC_REALLOC;
 
__LIBMEMALLOC_API int MEM_allocFree(mem_allocator_t *const allocator,
                                    void *const            ptr,
                                    const char *const      var);
 
__LIBMEMALLOC_API int MEM_enableGc(mem_allocator_t *const allocator);
 
__LIBMEMALLOC_API int MEM_disableGc(mem_allocator_t *const allocator);
 
/*< C++ Compatibility >*/
#ifdef __cplusplus
}
#endif
 
/*< end of header file >*/