tracy_rpmalloc.hpp

Go to the documentation of this file.

/* rpmalloc.h  -  Memory allocator  -  Public Domain  -  2016 Mattias Jansson
 *
 * This library provides a cross-platform lock free thread caching malloc implementation in C11.
 * The latest source code is always available at
 *
 * https://github.com/mjansson/rpmalloc
 *
 * This library is put in the public domain; you can redistribute it and/or modify it without any restrictions.
 *
 */

#pragma once

#include <stddef.h>
#include "../common/TracyApi.h"

namespace tracy
{

#if defined(__clang__) || defined(__GNUC__)
# define RPMALLOC_EXPORT __attribute__((visibility("default")))
# define RPMALLOC_ALLOCATOR 
# define RPMALLOC_ATTRIB_MALLOC __attribute__((__malloc__))
# if defined(__clang_major__) && (__clang_major__ < 4)
# define RPMALLOC_ATTRIB_ALLOC_SIZE(size)
# define RPMALLOC_ATTRIB_ALLOC_SIZE2(count, size)
# else
# define RPMALLOC_ATTRIB_ALLOC_SIZE(size) __attribute__((alloc_size(size)))
# define RPMALLOC_ATTRIB_ALLOC_SIZE2(count, size)  __attribute__((alloc_size(count, size)))
# endif
# define RPMALLOC_CDECL
#elif defined(_MSC_VER)
# define RPMALLOC_EXPORT
# define RPMALLOC_ALLOCATOR __declspec(allocator) __declspec(restrict)
# define RPMALLOC_ATTRIB_MALLOC
# define RPMALLOC_ATTRIB_ALLOC_SIZE(size)
# define RPMALLOC_ATTRIB_ALLOC_SIZE2(count,size)
# define RPMALLOC_CDECL __cdecl
#else
# define RPMALLOC_EXPORT
# define RPMALLOC_ALLOCATOR
# define RPMALLOC_ATTRIB_MALLOC
# define RPMALLOC_ATTRIB_ALLOC_SIZE(size)
# define RPMALLOC_ATTRIB_ALLOC_SIZE2(count,size)
# define RPMALLOC_CDECL
#endif

#ifndef RPMALLOC_CONFIGURABLE
#define RPMALLOC_CONFIGURABLE 0
#endif

#define RPMALLOC_NO_PRESERVE    1

typedef struct rpmalloc_global_statistics_t {
   size_t mapped;
   size_t mapped_peak;
   size_t cached;
   size_t huge_alloc;
   size_t huge_alloc_peak;
   size_t mapped_total;
   size_t unmapped_total;
} rpmalloc_global_statistics_t;

typedef struct rpmalloc_thread_statistics_t {
   size_t sizecache;
   size_t spancache;
   size_t thread_to_global;
   size_t global_to_thread;
   struct {
      size_t current;
      size_t peak;
      size_t to_global;
      size_t from_global;
      size_t to_cache;
      size_t from_cache;
      size_t to_reserved;
      size_t from_reserved;
      size_t map_calls;
   } span_use[32];
   struct {
      size_t alloc_current;
      size_t alloc_peak;
      size_t alloc_total;
      size_t free_total;
      size_t spans_to_cache;
      size_t spans_from_cache;
      size_t spans_from_reserved;
      size_t map_calls;
   } size_use[128];
} rpmalloc_thread_statistics_t;

typedef struct rpmalloc_config_t {
   //  aligned to the rpmalloc span size, which will always be a power of two.
   //  Optionally the function can store an alignment offset in the offset variable
   //  in case it performs alignment and the returned pointer is offset from the
   //  actual start of the memory region due to this alignment. The alignment offset
   //  will be passed to the memory unmap function. The alignment offset MUST NOT be
   //  larger than 65535 (storable in an uint16_t), if it is you must use natural
   //  alignment to shift it into 16 bits. If you set a memory_map function, you
   //  must also set a memory_unmap function or else the default implementation will
   //  be used for both.
   void* (*memory_map)(size_t size, size_t* offset);
   //  If release is set to non-zero, the unmap is for an entire span range as returned by
   //  a previous call to memory_map and that the entire range should be released. The
   //  release argument holds the size of the entire span range. If release is set to 0,
   //  the unmap is a partial decommit of a subset of the mapped memory range.
   //  If you set a memory_unmap function, you must also set a memory_map function or
   //  else the default implementation will be used for both.
   void (*memory_unmap)(void* address, size_t size, size_t offset, size_t release);
   //  requests to memory_map will be made with size set to a multiple of the page size.
   //  Used if RPMALLOC_CONFIGURABLE is defined to 1, otherwise system page size is used.
   size_t page_size;
   //  range (unless 0 - set to 0 to use the default span size). Used if RPMALLOC_CONFIGURABLE
   //  is defined to 1.
   size_t span_size;
   //  be used to minimize the system call overhead at the cost of virtual memory address
   //  space. The extra mapped pages will not be written until actually used, so physical
   //  committed memory should not be affected in the default implementation. Will be
   //  aligned to a multiple of spans that match memory page size in case of huge pages.
   size_t span_map_count;
   //  zero, the allocator will try to enable huge pages and auto detect the configuration.
   //  If this is set to non-zero and page_size is also non-zero, the allocator will
   //  assume huge pages have been configured and enabled prior to initializing the
   //  allocator.
   //  For Windows, see https://docs.microsoft.com/en-us/windows/desktop/memory/large-page-support
   //  For Linux, see https://www.kernel.org/doc/Documentation/vm/hugetlbpage.txt
   int enable_huge_pages;
} rpmalloc_config_t;

TRACY_API int
rpmalloc_initialize(void);

RPMALLOC_EXPORT int
rpmalloc_initialize_config(const rpmalloc_config_t* config);

RPMALLOC_EXPORT const rpmalloc_config_t*
rpmalloc_config(void);

TRACY_API void
rpmalloc_finalize(void);

TRACY_API void
rpmalloc_thread_initialize(void);

TRACY_API void
rpmalloc_thread_finalize(void);

RPMALLOC_EXPORT void
rpmalloc_thread_collect(void);

RPMALLOC_EXPORT int
rpmalloc_is_thread_initialized(void);

RPMALLOC_EXPORT void
rpmalloc_thread_statistics(rpmalloc_thread_statistics_t* stats);

RPMALLOC_EXPORT void
rpmalloc_global_statistics(rpmalloc_global_statistics_t* stats);

RPMALLOC_EXPORT void
rpmalloc_dump_statistics(void* file);

TRACY_API RPMALLOC_ALLOCATOR void*
rpmalloc(size_t size) RPMALLOC_ATTRIB_MALLOC RPMALLOC_ATTRIB_ALLOC_SIZE(1);

TRACY_API void
rpfree(void* ptr);

RPMALLOC_EXPORT RPMALLOC_ALLOCATOR void*
rpcalloc(size_t num, size_t size) RPMALLOC_ATTRIB_MALLOC RPMALLOC_ATTRIB_ALLOC_SIZE2(1, 2);

TRACY_API RPMALLOC_ALLOCATOR void*
rprealloc(void* ptr, size_t size) RPMALLOC_ATTRIB_MALLOC RPMALLOC_ATTRIB_ALLOC_SIZE(2);

//  with optional control flags (see RPMALLOC_NO_PRESERVE).
//  Alignment must be a power of two and a multiple of sizeof(void*),
//  and should ideally be less than memory page size. A caveat of rpmalloc
//  internals is that this must also be strictly less than the span size (default 64KiB)
RPMALLOC_EXPORT RPMALLOC_ALLOCATOR void*
rpaligned_realloc(void* ptr, size_t alignment, size_t size, size_t oldsize, unsigned int flags) RPMALLOC_ATTRIB_MALLOC RPMALLOC_ATTRIB_ALLOC_SIZE(3);

//  Alignment must be a power of two and a multiple of sizeof(void*),
//  and should ideally be less than memory page size. A caveat of rpmalloc
//  internals is that this must also be strictly less than the span size (default 64KiB)
RPMALLOC_EXPORT RPMALLOC_ALLOCATOR void*
rpaligned_alloc(size_t alignment, size_t size) RPMALLOC_ATTRIB_MALLOC RPMALLOC_ATTRIB_ALLOC_SIZE(2);

//  Alignment must be a power of two and a multiple of sizeof(void*),
//  and should ideally be less than memory page size. A caveat of rpmalloc
//  internals is that this must also be strictly less than the span size (default 64KiB)
RPMALLOC_EXPORT RPMALLOC_ALLOCATOR void*
rpmemalign(size_t alignment, size_t size) RPMALLOC_ATTRIB_MALLOC RPMALLOC_ATTRIB_ALLOC_SIZE(2);

//  Alignment must be a power of two and a multiple of sizeof(void*),
//  and should ideally be less than memory page size. A caveat of rpmalloc
//  internals is that this must also be strictly less than the span size (default 64KiB)
RPMALLOC_EXPORT int
rpposix_memalign(void **memptr, size_t alignment, size_t size);

RPMALLOC_EXPORT size_t
rpmalloc_usable_size(void* ptr);

}