rpmalloc

Documentation

Index

• func Calloc(num, size uintptr) uintptr
• func CallocCap(num, size uintptr) (uintptr, uintptr)
• func Free(ptr uintptr)
• func Init()
• func InitThread()
• func Malloc(size uintptr) uintptr
• func MallocCap(size uintptr) (uintptr, uintptr)
• func MallocZeroed(size uintptr) uintptr
• func MallocZeroedCap(size uintptr) (uintptr, uintptr)
• func ReadGlobalStats(stats *GlobalStats)
• func ReadThreadStats(stats *ThreadStats)
• func Realloc(ptr, size uintptr) uintptr
• func ReallocCap(ptr, size uintptr) (uintptr, uintptr)
• func StdFree(ptr uintptr)
• func StdMalloc(size uintptr) uintptr
• func UsableSize(ptr uintptr) uintptr
• type Config
• type GlobalStats
• type Heap
  • func AcquireHeap() *Heap
  • func (h *Heap) Alloc(size uintptr) uintptr
  • func (h *Heap) AllocCap(size uintptr) (uintptr, uintptr)
  • func (h *Heap) Calloc(num, size uintptr) uintptr
  • func (h *Heap) CallocCap(num, size uintptr) (uintptr, uintptr)
  • func (h *Heap) Free(ptr uintptr)
  • func (h *Heap) FreeAll()
  • func (h *Heap) Realloc(ptr, size uintptr, flags int32) uintptr
  • func (h *Heap) ReallocCap(ptr, size uintptr, flags int32) (uintptr, uintptr)
  • func (h *Heap) Release()
• type SizeUse
• type SpanStats
• type ThreadStats

Functions

func Calloc

func Calloc(num, size uintptr) uintptr

Calloc Allocates a memory block of at least the given size and zero initialize it.

func CallocCap

func CallocCap(num, size uintptr) (uintptr, uintptr)

Calloc Allocates a memory block of at least the given size and zero initialize it.

func Free

func Free(ptr uintptr)

Free the given memory block

func Init

func Init()

func InitThread

func InitThread()

func Malloc

func Malloc(size uintptr) uintptr

Malloc allocate a memory block of at least the given size

func MallocCap

func MallocCap(size uintptr) (uintptr, uintptr)

MallocCap allocate a memory block of at least the given size

func MallocZeroed

func MallocZeroed(size uintptr) uintptr

Malloc allocate a memory block of at least the given size

func MallocZeroedCap

func MallocZeroedCap(size uintptr) (uintptr, uintptr)

MallocZeroedCap allocate a memory block of at least the given size

func ReadGlobalStats

func ReadGlobalStats(stats *GlobalStats)

ReadGlobalStats get global statistics

func ReadThreadStats

func ReadThreadStats(stats *ThreadStats)

ReadThreadStats get thread statistics

func Realloc

func Realloc(ptr, size uintptr) uintptr

Realloc the given block to at least the given size

func ReallocCap

func ReallocCap(ptr, size uintptr) (uintptr, uintptr)

Realloc the given block to at least the given size

func StdFree

func StdFree(ptr uintptr)

Free the given memory block

func StdMalloc

func StdMalloc(size uintptr) uintptr

Malloc allocate a memory block of at least the given size

func UsableSize

func UsableSize(ptr uintptr) uintptr

UsableSize Query the usable size of the given memory block (from given pointer to the end of block)

Types

type Config

type Config struct {
	//! Map memory pages for the given number of bytes. The returned address MUST be
	//  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.
	MemoryMap uintptr
	//! Unmap the memory pages starting at address and spanning the given number of bytes.
	//  If release is set to non-zero, the unmap is for an entire span range as returned by
	//  a previous libfuzzerCall 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.
	MemoryUnmap uintptr
	//! Called when an assert fails, if asserts are enabled. Will use the standard assert()
	//  if this is not set.
	ErrorCallback uintptr
	//! Called when a libfuzzerCall to map memory pages fails (out of memory). If this callback is
	//  not set or returns zero the library will return a null pointer in the allocation
	//  libfuzzerCall. If this callback returns non-zero the map libfuzzerCall will be retried. The argument
	//  passed is the number of bytes that was requested in the map libfuzzerCall. Only used if
	//  the default system memory map function is used (memory_map callback is not set).
	MapFailCallback uintptr
	//! Size of memory pages. The page size MUST be a power of two. All memory mapping
	//  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.
	PageSize uintptr
	//! Size of a span of memory blocks. MUST be a power of two, and in [4096,262144]
	//  range (unless 0 - set to 0 to use the default span size). Used if RPMALLOC_CONFIGURABLE
	//  is defined to 1.
	SpanSize uintptr
	//! Number of spans to map at each request to map new virtual memory blocks. This can
	//  be used to minimize the system libfuzzerCall 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.
	SpanMapCount uintptr
	//! Enable use of large/huge pages. If this flag is set to non-zero and page size is
	//  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
	EnableHugePages int32
	Unused          int32
}

type GlobalStats

type GlobalStats struct {
	//! Current amount of virtual memory mapped, all of which might not have been committed (only if ENABLE_STATISTICS=1)
	Mapped uintptr
	//! Peak amount of virtual memory mapped, all of which might not have been committed (only if ENABLE_STATISTICS=1)
	MappedPeak uintptr
	//! Current amount of memory in global caches for small and medium sizes (<32KiB)
	Cached uintptr
	//! Current amount of memory allocated in huge allocations, i.e larger than LARGE_SIZE_LIMIT which is 2MiB by default (only if ENABLE_STATISTICS=1)
	HugeAlloc uintptr
	//! Peak amount of memory allocated in huge allocations, i.e larger than LARGE_SIZE_LIMIT which is 2MiB by default (only if ENABLE_STATISTICS=1)
	HugeAllocPeak uintptr
	//! Total amount of memory mapped since initialization (only if ENABLE_STATISTICS=1)
	MappedTotal uintptr
	//! Total amount of memory unmapped since initialization  (only if ENABLE_STATISTICS=1)
	UnmappedTotal uintptr
}

type Heap

type Heap C.rpmalloc_heap_t

func AcquireHeap

func AcquireHeap() *Heap

func (*Heap) Alloc

func (h *Heap) Alloc(size uintptr) uintptr

Alloc Allocate a memory block of at least the given size using the given heap.

func (*Heap) AllocCap

func (h *Heap) AllocCap(size uintptr) (uintptr, uintptr)

AllocCap Allocate a memory block of at least the given size using the given heap.

func (*Heap) Calloc

func (h *Heap) Calloc(num, size uintptr) uintptr

Calloc Allocate a memory block of at least the given size using the given heap and zero initialize it.

func (*Heap) CallocCap

func (h *Heap) CallocCap(num, size uintptr) (uintptr, uintptr)

Calloc Allocate a memory block of at least the given size using the given heap and zero initialize it.

func (*Heap) Free

func (h *Heap) Free(ptr uintptr)

Free the given memory block from the given heap. The memory block MUST be allocated by the same heap given to this function.

func (*Heap) FreeAll

func (h *Heap) FreeAll()

FreeAll memory allocated by the heap

func (*Heap) Realloc

func (h *Heap) Realloc(ptr, size uintptr, flags int32) uintptr

Realloc Reallocate the given block to at least the given size. The memory block MUST be allocated by the same heap given to this function.

func (*Heap) ReallocCap

func (h *Heap) ReallocCap(ptr, size uintptr, flags int32) (uintptr, uintptr)

ReallocCap Reallocate the given block to at least the given size. The memory block MUST be allocated by the same heap given to this function.

func (*Heap) Release

func (h *Heap) Release()

type SizeUse

type SizeUse struct {
	//! Current number of allocations
	AllocCurrent uintptr
	//! Peak number of allocations
	AllocPeak uintptr
	//! Total number of allocations
	AllocTotal uintptr
	//! Total number of frees
	FreeTotal uintptr
	//! Number of spans transitioned to cache
	SpansToCache uintptr
	//! Number of spans transitioned from cache
	SpansFromCache uintptr
	//! Number of spans transitioned from reserved state
	SpansFromReserved uintptr
	//! Number of raw memory map calls (not hitting the reserve spans but resulting in actual OS mmap calls)
	MapCalls uintptr
}

type SpanStats

type SpanStats struct {
	//! Currently used number of spans
	Current uintptr
	//! High water mark of spans used
	Peak uintptr
	//! Number of spans transitioned to global cache
	ToGlobal uintptr
	//! Number of spans transitioned from global cache
	FromGlobal uintptr
	//! Number of spans transitioned to thread cache
	ToCache uintptr
	//! Number of spans transitioned from thread cache
	FromCache uintptr
	//! Number of spans transitioned to reserved state
	ToReserved uintptr
	//! Number of spans transitioned from reserved state
	FromReserved uintptr
	//! Number of raw memory map calls (not hitting the reserve spans but resulting in actual OS mmap calls)
	MapCalls uintptr
}

type ThreadStats

type ThreadStats struct {
	//! Current number of bytes available in thread size class caches for small and medium sizes (<32KiB)
	SizeCache uintptr
	//! Current number of bytes available in thread span caches for small and medium sizes (<32KiB)
	SpanCache uintptr
	//! Total number of bytes transitioned from thread cache to global cache (only if ENABLE_STATISTICS=1)
	ThreadToGlobal uintptr
	//! Total number of bytes transitioned from global cache to thread cache (only if ENABLE_STATISTICS=1)
	GlobalToThread uintptr
	//! Per span count statistics (only if ENABLE_STATISTICS=1)
	SpanUse [64]SpanStats
	//! Per size class statistics (only if ENABLE_STATISTICS=1)
	SizeUse [128]SizeUse
}