Global

class method atomic_add32(val: ^atomic32_t; add: Int32): Int32

static Int32 atomic_add32(atomic32_t* val, Int32 add)

static func atomic_add32(_ val: UnsafeMutablePointer<atomic32_t>, _ add: Int32) -> Int32

static Int32 atomic_add32(atomic32_t* val, Int32 add)

Shared Function atomic_add32(val As Ptr(Of atomic32_t), add As Int32) As Int32

class method atomic_cas_ptr(dst: ^atomicptr_t; val: ^void; ref: ^void): Int32

static Int32 atomic_cas_ptr(atomicptr_t* dst, void* val, void* ref)

static func atomic_cas_ptr(_ dst: UnsafeMutablePointer<atomicptr_t>, _ val: UnsafeMutablePointer<void>, _ ref: UnsafeMutablePointer<void>) -> Int32

static Int32 atomic_cas_ptr(atomicptr_t* dst, void* val, void* ref)

Shared Function atomic_cas_ptr(dst As Ptr(Of atomicptr_t), val As Ptr(Of Void), ref As Ptr(Of Void)) As Int32

class method atomic_incr32(val: ^atomic32_t): Int32

static Int32 atomic_incr32(atomic32_t* val)

static func atomic_incr32(_ val: UnsafeMutablePointer<atomic32_t>) -> Int32

static Int32 atomic_incr32(atomic32_t* val)

Shared Function atomic_incr32(val As Ptr(Of atomic32_t)) As Int32

class method atomic_load_ptr(src: ^atomicptr_t): ^void

static void* atomic_load_ptr(atomicptr_t* src)

static func atomic_load_ptr(_ src: UnsafeMutablePointer<atomicptr_t>) -> UnsafeMutablePointer<void>

static void* atomic_load_ptr(atomicptr_t* src)

Shared Function atomic_load_ptr(src As Ptr(Of atomicptr_t)) As Ptr(Of Void)

class method atomic_load32(src: ^atomic32_t): Int32

static Int32 atomic_load32(atomic32_t* src)

static func atomic_load32(_ src: UnsafeMutablePointer<atomic32_t>) -> Int32

static Int32 atomic_load32(atomic32_t* src)

Shared Function atomic_load32(src As Ptr(Of atomic32_t)) As Int32

class method atomic_store_ptr(dst: ^atomicptr_t; val: ^void)

static void atomic_store_ptr(atomicptr_t* dst, void* val)

static func atomic_store_ptr(_ dst: UnsafeMutablePointer<atomicptr_t>, _ val: UnsafeMutablePointer<void>)

static void atomic_store_ptr(atomicptr_t* dst, void* val)

Shared Sub atomic_store_ptr(dst As Ptr(Of atomicptr_t), val As Ptr(Of Void))

class method atomic_store32(dst: ^atomic32_t; val: Int32)

static void atomic_store32(atomic32_t* dst, Int32 val)

static func atomic_store32(_ dst: UnsafeMutablePointer<atomic32_t>, _ val: Int32)

static void atomic_store32(atomic32_t* dst, Int32 val)

Shared Sub atomic_store32(dst As Ptr(Of atomic32_t), val As Int32)

class method get_thread_heap: ^heap_t

static heap_t* get_thread_heap()

static func get_thread_heap() -> UnsafeMutablePointer<heap_t>

static heap_t* get_thread_heap()

Shared Function get_thread_heap() As Ptr(Of heap_t)

class method mmap(addr: ^void; size: IntPtr; prot: Int32; flags: Int32; handle: IntPtr; offset: IntPtr): ^void

static void* mmap(void* addr, IntPtr size, Int32 prot, Int32 flags, IntPtr handle, IntPtr offset)

static func mmap(_ addr: UnsafeMutablePointer<void>, _ size: IntPtr, _ prot: Int32, _ flags: Int32, _ handle: IntPtr, _ offset: IntPtr) -> UnsafeMutablePointer<void>

static void* mmap(void* addr, IntPtr size, Int32 prot, Int32 flags, IntPtr handle, IntPtr offset)

Shared Function mmap(addr As Ptr(Of Void), size As IntPtr, prot As Int32, flags As Int32, handle As IntPtr, offset As IntPtr) As Ptr(Of Void)

class method rpaligned_alloc(alignment: IntPtr; size: IntPtr): ^void

static void* rpaligned_alloc(IntPtr alignment, IntPtr size)

static func rpaligned_alloc(_ alignment: IntPtr, _ size: IntPtr) -> UnsafeMutablePointer<void>

static void* rpaligned_alloc(IntPtr alignment, IntPtr size)

Shared Function rpaligned_alloc(alignment As IntPtr, size As IntPtr) As Ptr(Of Void)

class method rpaligned_realloc(ptr: ^void; alignment: IntPtr; size: IntPtr; oldsize: IntPtr; flags: UInt32): ^void

static void* rpaligned_realloc(void* ptr, IntPtr alignment, IntPtr size, IntPtr oldsize, UInt32 flags)

static func rpaligned_realloc(_ ptr: UnsafeMutablePointer<void>, _ alignment: IntPtr, _ size: IntPtr, _ oldsize: IntPtr, _ flags: UInt32) -> UnsafeMutablePointer<void>

static void* rpaligned_realloc(void* ptr, IntPtr alignment, IntPtr size, IntPtr oldsize, UInt32 flags)

Shared Function rpaligned_realloc(ptr As Ptr(Of Void), alignment As IntPtr, size As IntPtr, oldsize As IntPtr, flags As UInt32) As Ptr(Of Void)

class method rpcalloc(num: IntPtr; size: IntPtr): ^void

static void* rpcalloc(IntPtr num, IntPtr size)

static func rpcalloc(_ num: IntPtr, _ size: IntPtr) -> UnsafeMutablePointer<void>

static void* rpcalloc(IntPtr num, IntPtr size)

Shared Function rpcalloc(num As IntPtr, size As IntPtr) As Ptr(Of Void)

class method rpfree(ptr: ^void)

static void rpfree(void* ptr)

static func rpfree(_ ptr: UnsafeMutablePointer<void>)

static void rpfree(void* ptr)

Shared Sub rpfree(ptr As Ptr(Of Void))

class method rpmalloc(size: IntPtr): ^void

static void* rpmalloc(IntPtr size)

static func rpmalloc(_ size: IntPtr) -> UnsafeMutablePointer<void>

static void* rpmalloc(IntPtr size)

Shared Function rpmalloc(size As IntPtr) As Ptr(Of Void)

class method rpmalloc_config: ^rpmalloc_config_t

static rpmalloc_config_t* rpmalloc_config()

static func rpmalloc_config() -> UnsafeMutablePointer<rpmalloc_config_t>

static rpmalloc_config_t* rpmalloc_config()

Shared Function rpmalloc_config() As Ptr(Of rpmalloc_config_t)

class method rpmalloc_finalize

static void rpmalloc_finalize()

static func rpmalloc_finalize()

static void rpmalloc_finalize()

Shared Sub rpmalloc_finalize()

class method rpmalloc_global_statistics(stats: ^rpmalloc_global_statistics_t)

static void rpmalloc_global_statistics(rpmalloc_global_statistics_t* stats)

static func rpmalloc_global_statistics(_ stats: UnsafeMutablePointer<rpmalloc_global_statistics_t>)

static void rpmalloc_global_statistics(rpmalloc_global_statistics_t* stats)

Shared Sub rpmalloc_global_statistics(stats As Ptr(Of rpmalloc_global_statistics_t))

class method rpmalloc_initialize: Int32

static Int32 rpmalloc_initialize()

static func rpmalloc_initialize() -> Int32

static Int32 rpmalloc_initialize()

Shared Function rpmalloc_initialize() As Int32

class method rpmalloc_initialize_config(config: ^rpmalloc_config_t): Int32

static Int32 rpmalloc_initialize_config(rpmalloc_config_t* config)

static func rpmalloc_initialize_config(_ config: UnsafeMutablePointer<rpmalloc_config_t>) -> Int32

static Int32 rpmalloc_initialize_config(rpmalloc_config_t* config)

Shared Function rpmalloc_initialize_config(config As Ptr(Of rpmalloc_config_t)) As Int32

class method rpmalloc_is_thread_initialized: Int32

static Int32 rpmalloc_is_thread_initialized()

static func rpmalloc_is_thread_initialized() -> Int32

static Int32 rpmalloc_is_thread_initialized()

Shared Function rpmalloc_is_thread_initialized() As Int32

class method rpmalloc_thread_collect

static void rpmalloc_thread_collect()

static func rpmalloc_thread_collect()

static void rpmalloc_thread_collect()

Shared Sub rpmalloc_thread_collect()

class method rpmalloc_thread_finalize

static void rpmalloc_thread_finalize()

static func rpmalloc_thread_finalize()

static void rpmalloc_thread_finalize()

Shared Sub rpmalloc_thread_finalize()

class method rpmalloc_thread_initialize

static void rpmalloc_thread_initialize()

static func rpmalloc_thread_initialize()

static void rpmalloc_thread_initialize()

Shared Sub rpmalloc_thread_initialize()

class method rpmalloc_thread_statistics(stats: ^rpmalloc_thread_statistics_t)

static void rpmalloc_thread_statistics(rpmalloc_thread_statistics_t* stats)

static func rpmalloc_thread_statistics(_ stats: UnsafeMutablePointer<rpmalloc_thread_statistics_t>)

static void rpmalloc_thread_statistics(rpmalloc_thread_statistics_t* stats)

Shared Sub rpmalloc_thread_statistics(stats As Ptr(Of rpmalloc_thread_statistics_t))

class method rpmalloc_usable_size(ptr: ^void): IntPtr

static IntPtr rpmalloc_usable_size(void* ptr)

static func rpmalloc_usable_size(_ ptr: UnsafeMutablePointer<void>) -> IntPtr

static IntPtr rpmalloc_usable_size(void* ptr)

Shared Function rpmalloc_usable_size(ptr As Ptr(Of Void)) As IntPtr

class method rpmemalign(alignment: IntPtr; size: IntPtr): ^void

static void* rpmemalign(IntPtr alignment, IntPtr size)

static func rpmemalign(_ alignment: IntPtr, _ size: IntPtr) -> UnsafeMutablePointer<void>

static void* rpmemalign(IntPtr alignment, IntPtr size)

Shared Function rpmemalign(alignment As IntPtr, size As IntPtr) As Ptr(Of Void)

class method rpposix_memalign(memptr: ^^void; alignment: IntPtr; size: IntPtr): Int32

static Int32 rpposix_memalign(void** memptr, IntPtr alignment, IntPtr size)

static func rpposix_memalign(_ memptr: UnsafeMutablePointer<UnsafeMutablePointer<void>>, _ alignment: IntPtr, _ size: IntPtr) -> Int32

static Int32 rpposix_memalign(void** memptr, IntPtr alignment, IntPtr size)

Shared Function rpposix_memalign(memptr As Ptr(Of Ptr(Of Void)), alignment As IntPtr, size As IntPtr) As Int32

class method rprealloc(ptr: ^void; size: IntPtr): ^void

static void* rprealloc(void* ptr, IntPtr size)

static func rprealloc(_ ptr: UnsafeMutablePointer<void>, _ size: IntPtr) -> UnsafeMutablePointer<void>

static void* rprealloc(void* ptr, IntPtr size)

Shared Function rprealloc(ptr As Ptr(Of Void), size As IntPtr) As Ptr(Of Void)

class method set_thread_heap(heap: ^heap_t)

static void set_thread_heap(heap_t* heap)

static func set_thread_heap(_ heap: UnsafeMutablePointer<heap_t>)

static void set_thread_heap(heap_t* heap)

Shared Sub set_thread_heap(heap As Ptr(Of heap_t))