Unit HeapManager
From Ultibo.org
Return to Unit Reference
Description
Ultibo Heap Manager interface unit
To be documented
Constants
Heap specific constants
HEAP_MIN_* HEAP_MIN_BLOCK = 33;
|
SizeOf(THeapBlock) + 1 |
HEAP_MIN_ALIGN = 64;
|
SizeOf(THeapBlock) * 2 Must be greater than or equal to HEAP_MIN_BLOCK, must be a power of 2 |
Heap signature
HEAP_SIGNATURE_* HEAP_SIGNATURE = $E84DF600;
|
|
HEAP_SIGNATURE_MASK = $FFFFFF00;
|
Heap block state
HEAP_STATE_* HEAP_STATE_FREE = 0;
|
|
HEAP_STATE_USED = 1;
|
|
HEAP_STATE_MASK = $000000FF;
|
|
HEAP_STATE_ALL = 2;
|
Only for use by GetHeapBlockCount/GetHeapBlockMin/GetHeapBlockMax |
Heap block flag
HEAP_FLAG_* HEAP_FLAG_NORMAL = $00000000;
|
A normal memory block |
HEAP_FLAG_SHARED = $00000001;
|
A sharable memory block, usually marked as sharable in the page tables of the memory management unit |
HEAP_FLAG_LOCAL = $00000002;
|
A local memory block with an affinity to a specific processor, usually marked as non global in the page tables of the memory management unit |
HEAP_FLAG_CODE = $00000004;
|
A code memory block (with an optional affinity to a specific processor), usually marked as executable in the page tables of the memory management unit |
HEAP_FLAG_DEVICE = $00000008;
|
A device memory block, usually marked as device memory in the page tables of the memory management unit |
HEAP_FLAG_NOCACHE = $00000010;
|
A non cached memory block, usually marked as not cacheable in the page tables of the memory management unit |
HEAP_FLAG_NONSHARED = $00000020;
|
A non shared memory block, usually marked as not shareable in the page tables of the memory management unit |
HEAP_FLAG_LOCKED = $00000040;
|
A locked memory block (Not currently implemented in Ultibo) |
HEAP_FLAG_IRQ = $00000080;
|
An IRQ allocatable memory block |
HEAP_FLAG_FIQ = $00000100;
|
An FIQ allocatable memory block |
HEAP_FLAG_RECLAIM = $00000200;
|
A reclaimable memory block (eg Disk Cache)(with a registered callback to reclaim as required for normal memory) |
HEAP_FLAG_CUSTOM = $08000000;
|
A custom flag reserved for non standard uses |
HEAP_FLAG_ALL = $FFFFFFFF;
|
Only for use by GetHeapBlockCount/GetHeapBlockMin/GetHeapBlockMax |
HEAP_FLAG_INVALID = $FFFFFFFF;
|
Return value from MemFlags/IRQ/FIQ on invalid |
Heap small block
HEAP_SMALL_* HEAP_SMALL_MIN = 32;
|
SizeOf(THeapBlock) Minimum size of a small heap block |
HEAP_SMALL_MAX = SIZE_4K;
|
Maximum size of a small heap block |
HEAP_SMALL_ALIGN = 4;
|
SizeOf(LongWord); Alignment for small heap blocks |
HEAP_SMALL_SHIFT = 2;
|
Size to Index conversion (Divide by 4) |
HEAP_SMALL_LOW = (HEAP_SMALL_MIN div HEAP_SMALL_ALIGN);
|
8 |
HEAP_SMALL_HIGH = (HEAP_SMALL_MAX div HEAP_SMALL_ALIGN);
|
1024 |
Type definitions
Heap callback
THeapCallback = function(Size:PtrUInt):LongWord;
|
Heap block
PHeapBlock = ^THeapBlock;
THeapBlock = record
Size:PtrUInt;
|
Size of the Heap Block (including the size of this structure) |
State:LongWord;
|
State of the Heap Block (eg HEAP_STATE_FREE) |
Flags:LongWord;
|
Flags of the Heap Block (eg HEAP_FLAG_SHARED) |
Affinity:LongWord;
|
CPU Affinity of the Heap Block (eg CPU_AFFINITY_0) |
Prev:PHeapBlock;
|
Previous Heap Block in list |
Next:PHeapBlock;
|
Next Heap Block in list |
PrevLink:PHeapBlock;
|
Previous Free/Used Block in list |
NextLink:PHeapBlock;
|
Next Free/Used Block in list |
Heap small blocks
PSmallBlocks = ^TSmallBlocks;
TSmallBlocks = array[HEAP_SMALL_LOW..HEAP_SMALL_HIGH] of PHeapBlock; {8..1024}
Heap lock
PHeapLock = ^THeapLock;
THeapLock = record
Lock:THandle;
|
|
IRQLock:THandle;
|
|
FIQLock:THandle;
|
|
AcquireLock:function(Handle:THandle):LongWord;
|
|
ReleaseLock:function(Handle:THandle):LongWord;
|
|
AcquireIRQLock:function(Handle:THandle):LongWord;
|
|
ReleaseIRQLock:function(Handle:THandle):LongWord;
|
|
AcquireFIQLock:function(Handle:THandle):LongWord;
|
|
ReleaseFIQLock:function(Handle:THandle):LongWord;
|
Heap statistics
PHeapStatistics = ^THeapStatistics;
THeapStatistics = record
| Get/Alloc/Realloc | |
GetCount:LongWord;
|
|
AllocCount:LongWord;
|
|
ReallocCount:LongWord;
|
|
GetAlignedCount:LongWord;
|
|
AllocAlignedCount:LongWord;
|
|
ReallocAlignedCount:LongWord;
|
|
GetSharedCount:LongWord;
|
|
AllocSharedCount:LongWord;
|
|
ReallocSharedCount:LongWord;
|
|
GetLocalCount:LongWord;
|
|
AllocLocalCount:LongWord;
|
|
ReallocLocalCount:LongWord;
|
|
GetCodeCount:LongWord;
|
|
AllocCodeCount:LongWord;
|
|
ReallocCodeCount:LongWord;
|
|
GetDeviceCount:LongWord;
|
|
AllocDeviceCount:LongWord;
|
|
ReallocDeviceCount:LongWord;
|
|
GetNoCacheCount:LongWord;
|
|
AllocNoCacheCount:LongWord;
|
|
ReallocNoCacheCount:LongWord;
|
|
GetNonSharedCount:LongWord;
|
|
AllocNonSharedCount:LongWord;
|
|
ReallocNonSharedCount:LongWord;
|
|
GetIRQCount:LongWord;
|
|
AllocIRQCount:LongWord;
|
|
ReallocIRQCount:LongWord;
|
|
GetFIQCount:LongWord;
|
|
AllocFIQCount:LongWord;
|
|
ReallocFIQCount:LongWord;
|
|
| Free | |
FreeCount:LongWord;
|
|
FreeIRQCount:LongWord;
|
|
FreeFIQCount:LongWord;
|
|
FreeSizeCount:LongWord;
|
|
| Size | |
SizeCount:LongWord;
|
|
SizeIRQCount:LongWord;
|
|
SizeFIQCount:LongWord;
|
|
| Flags | |
FlagsCount:LongWord;
|
|
FlagsIRQCount:LongWord;
|
|
FlagsFIQCount:LongWord;
|
|
| Register | |
RegisterCount:LongWord;
|
|
| Request | |
RequestCount:LongWord;
|
|
RequestSharedCount:LongWord;
|
|
RequestLocalCount:LongWord;
|
|
RequestCodeCount:LongWord;
|
|
RequestDeviceCount:LongWord;
|
|
RequestNoCacheCount:LongWord;
|
|
RequestNonSharedCount:LongWord;
|
|
RequestIRQCount:LongWord;
|
|
RequestFIQCount:LongWord;
|
|
| Get Internal | |
GetZeroCount:LongWord;
|
|
GetRemainCount:LongWord;
|
|
GetInvalidCount:LongWord;
|
|
GetUnavailableCount:LongWord;
|
|
GetAddFailCount:LongWord;
|
|
GetSplitFailCount:LongWord;
|
|
GetRemoveFailCount:LongWord;
|
|
| Realloc Internal | |
ReallocZeroCount:LongWord;
|
|
ReallocSmallerCount:LongWord;
|
|
ReallocLargerCount:LongWord;
|
|
ReallocReleaseCount:LongWord;
|
|
ReallocReleaseBytes:LongWord;
|
|
ReallocAddFailCount:LongWord;
|
|
ReallocSplitFailCount:LongWord;
|
|
ReallocRemoveFailCount:LongWord;
|
|
| GetAligned Internal | |
GetAlignedRemainCount:LongWord;
|
|
GetAlignedInvalidCount:LongWord;
|
|
GetAlignedUndersizeCount:LongWord;
|
|
GetAlignedUnavailableCount:LongWord;
|
|
GetAlignedAddFailCount:LongWord;
|
|
GetAlignedSplitFailCount:LongWord;
|
|
GetAlignedRemoveFailCount:LongWord;
|
|
GetAlignedOrphanCount:LongWord;
|
|
GetAlignedOrphanBytes:LongWord;
|
|
GetAlignedReleaseCount:LongWord;
|
|
GetAlignedReleaseBytes:LongWord;
|
|
| Free Internal | |
FreeInvalidCount:LongWord;
|
|
FreeAddFailCount:LongWord;
|
|
FreeMergeFailCount:LongWord;
|
|
FreeRemoveFailCount:LongWord;
|
|
| Size Internal | |
SizeInvalidCount:LongWord;
|
|
| Flags Internal | |
FlagsInvalidCount:LongWord;
|
|
| Register Internal | |
RegisterInvalidCount:LongWord;
|
|
RegisterAddFailCount:LongWord;
|
|
| Request Internal | |
RequestInvalidCount:LongWord;
|
|
RequestAddFailCount:LongWord;
|
|
RequestSplitFailCount:LongWord;
|
|
RequestRemoveFailCount:LongWord;
|
|
RequestUnavailableCount:LongWord;
|
|
| Split Internal | |
SplitCount:LongWord;
|
|
| Merge Internal | |
MergePrevCount:LongWord;
|
|
MergeNextCount:LongWord;
|
|
| Block Internal | |
GetSmallCount:LongWord;
|
|
GetLargeCount:LongWord;
|
|
AddSmallCount:LongWord;
|
|
AddLargeCount:LongWord;
|
|
RemoveSmallCount:LongWord;
|
|
RemoveLargeCount:LongWord;
|
|
SmallUnavailableCount:LongWord;
|
|
Heap snapshot
PHeapSnapshot = ^THeapSnapshot;
THeapSnapshot = record
| Snapshot Properties | |
Adddress:PtrUInt;
|
Address of the Heap Block |
Size:PtrUInt;
|
Size of the Heap Block (including the size of the THeapBlock structure) |
State:LongWord;
|
State of the Heap Block (eg HEAP_STATE_FREE) |
Flags:LongWord;
|
Flags of the Heap Block (eg HEAP_FLAG_SHARED) |
Affinity:LongWord;
|
CPU Affinity of the Heap Block (eg CPU_AFFINITY_0) |
| Internal Properties | |
Next:PHeapSnapshot;
|
Next entry in Heap snapshot |
Public variables
None defined
Function declarations
Initialization functions
procedure RegisterMemoryManager;
Description: To be documented
| Note | None documented |
|---|
procedure RegisterHeapBlock(Address:Pointer; Size:PtrUInt);
Description: To be documented
| Note | None documented |
|---|
function RequestHeapBlock(Hint:Pointer; Size:PtrUInt; Flags,Affinity:LongWord):Pointer;
Description: Request registration a Heap Block with specified flags and affinity within an existing block
| Hint | The hint provides the requested base address of the heap block but may be overridden by the memory manager if the block is already partially or fully allocated, pass nil if any heap block is suitable |
|---|---|
| Size | The size provides the requested size of the heap block. Size must be a power of 2 and both Hint and the returned pointer must be aligned on a multiple of HEAP_REQUEST_ALIGNMENT. Flags provides the heap block flags such as shared, local, code, device, nocache etc. |
| Affinity | The affinity provides the processor affinity mask, a mask of 0 indicates no specific processor |
| Return | The return is the heap block that has been registered or nil if the request failed |
| Note | To allocate this memory use GetMemEx/AllocMemEx etc. The return value points directly to the heap block, to access the memory referenced by the heap block you must add SizeOf(THeapBlock) to this value. |
function RequestSharedHeapBlock(Hint:Pointer; Size:PtrUInt):Pointer;
Description: Request registration of a Shared Heap Block within an existing block
| Hint | The hint provides the requested base address of the shared heap block but may be overridden by the memory manager if the block is already partially or fully allocated, pass nil if any heap block is suitable |
|---|---|
| Size | The size provides the requested size of the heap block. Size must be a power of 2 and both Hint and the returned pointer must be aligned on a multiple of HEAP_REQUEST_ALIGNMENT. |
| Return | The return is the heap block that has been marked as shared or nil if the request failed (the memory management unit should mark this region of memory as sharable) |
| Note | To allocate shared memory use GetSharedMem/AllocSharedMem etc. The return value points directly to the heap block, to access the memory referenced by the heap block you must add SizeOf(THeapBlock) to this value. |
function RequestLocalHeapBlock(Hint:Pointer; Size:PtrUInt; Affinity:LongWord):Pointer;
Description: Request registration of a Local Heap Block within an existing block
| Hint | The hint provides a requested base address of the local heap block but may be overridden by the memory manager if the block is already partially or fully allocated, pass nil if any heap block is suitable |
|---|---|
| Size | The size provides the requested size of the heap block. Size must be a power of 2 and both Hint and the returned pointer must be aligned on a multiple of HEAP_REQUEST_ALIGNMENT. |
| Affinity | The affinity provides the processor affinity mask, a mask of 0 indicates no specific processor |
| Return | The return is the heap block that has been marked as local or nil if the request failed (The memory management unit should mark this region of memory as local or non global) |
| Note | To allocate local memory use GetLocalMem/AllocLocalMem etc. The return value points directly to the heap block, to access the memory referenced by the heap block you must add SizeOf(THeapBlock) to this value. |
function RequestCodeHeapBlock(Hint:Pointer; Size:PtrUInt; Affinity:LongWord):Pointer;
Description: Request registration of a Code Heap Block within an existing block
| Hint | The hint provides a requested base address of the code heap block but may be overridden by the memory manager if the block is already partially or fully allocated, pass nil if any heap block is suitable |
|---|---|
| Size | The size provides the requested size of the heap block. Size must be a power of 2 and both Hint and the returned pointer must be aligned on a multiple of HEAP_REQUEST_ALIGNMENT. |
| Affinity | The affinity provides the processor affinity mask, a mask of 0 indicates no specific processor |
| Return | The return is the heap block that has been marked as code or nil if the request failed (The memory management unit should mark this region of memory as executable) |
| Note | To allocate code memory use GetCodeMem/AllocCodeMem etc. The return value points directly to the heap block, to access the memory referenced by the heap block you must add SizeOf(THeapBlock) to this value. |
function RequestDeviceHeapBlock(Hint:Pointer; Size:PtrUInt):Pointer;
Description: Request registration of a Device Heap Block within an existing block
| Hint | The hint provides the requested base address of the device heap block but may be overridden by the memory manager if the block is already partially or fully allocated, pass nil if any heap block is suitable |
|---|---|
| Size | The size provides the requested size of the heap block. Size must be a power of 2 and both Hint and the returned pointer must be aligned on a multiple of HEAP_REQUEST_ALIGNMENT. |
| Return | The return is the heap block that has been marked as device or nil if the request failed (The memory management unit should mark this region of memory as sharable) |
| Note | To allocate device memory use GetDeviceMem/AllocDeviceMem etc. The return value points directly to the heap block, to access the memory referenced by the heap block you must add SizeOf(THeapBlock) to this value. |
function RequestNoCacheHeapBlock(Hint:Pointer; Size:PtrUInt):Pointer;
Description: Request registration of a Non Cached Heap Block within an existing block
| Hint | The hint provides the requested base address of the non cached heap block but may be overridden by the memory manager if the block is already partially or fully allocated, pass nil if any heap block is suitable |
|---|---|
| Size | The size provides the requested size of the heap block. Size must be a power of 2 and both Hint and the returned pointer must be aligned on a multiple of HEAP_REQUEST_ALIGNMENT. |
| Return | The return is the heap block that has been marked as non cached or nil if the request failed (The memory management unit should mark this region of memory as sharable) |
| Note | To allocate non cached memory use GetNoCacheMem/AllocNoCacheMem etc. The return value points directly to the heap block, to access the memory referenced by the heap block you must add SizeOf(THeapBlock) to this value. |
function RequestNonSharedHeapBlock(Hint:Pointer; Size:PtrUInt):Pointer;
Description: Request registration of a Non Shared Heap Block within an existing block
| Hint | The hint provides the requested base address of the non shared heap block but may be overridden by the memory manager if the block is already partially or fully allocated, pass nil if any heap block is suitable |
|---|---|
| Size | The size provides the requested size of the heap block. Size must be a power of 2 and both Hint and the returned pointer must be aligned on a multiple of HEAP_REQUEST_ALIGNMENT. |
| Return | The return is the heap block that has been marked as non shared or nil if the request failed (The memory management unit should mark this region of memory as sharable) |
| Note | To allocate non shared memory use GetNonSharedMem/AllocNonSharedMem etc. The return value points directly to the heap block, to access the memory referenced by the heap block you must add SizeOf(THeapBlock) to this value. |
function RequestIRQHeapBlock(Hint:Pointer; Size:PtrUInt; Affinity:LongWord):Pointer;
Description: Request registration of an IRQ Heap Block within an existing block
| Hint | The hint provides a requested base address of the IRQ heap block but may be overridden by the memory manager if the block is already partially or fully allocated, pass nil if any heap block is suitable |
|---|---|
| Size | The size provides the requested size of the heap block. Size must be a power of 2 and both Hint and the returned pointer must be aligned on a multiple of HEAP_REQUEST_ALIGNMENT. |
| Affinity | The affinity provides the processor affinity mask, a mask of 0 indicates no specific processor |
| Return | The return is the heap block that has been marked as IRQ or nil if the request failed |
| Note | To allocate IRQ memory use GetIRQMem/AllocIRQMem etc. The return value points directly to the heap block, to access the memory referenced by the heap block you must add SizeOf(THeapBlock) to this value. |
function RequestFIQHeapBlock(Hint:Pointer; Size:PtrUInt; Affinity:LongWord):Pointer;
Description: Request registration of an FIQ Heap Block within an existing block
| Hint | The hint provides a requested base address of the FIQ heap block but may be overridden by the memory manager if the block is already partially or fully allocated, pass nil if any heap block is suitable |
|---|---|
| Size | The size provides the requested size of the heap block. Size must be a power of 2 and both Hint and the returned pointer must be aligned on a multiple of HEAP_REQUEST_ALIGNMENT. |
| Affinity | The affinity provides the processor affinity mask, a mask of 0 indicates no specific processor |
| Return | The return is the heap block that has been marked as FIQ or nil if the request failed |
| Note | To allocate FIQ memory use GetFIQMem/AllocFIQMem etc. The return value points directly to the heap block, to access the memory referenced by the heap block you must add SizeOf(THeapBlock) to this value. |
Heap functions
function GetMemEx(Size:PtrUInt; Flags,Affinity:LongWord):Pointer;
Description: Allocate a block of memory with the flags and affinity requested
| Note | None documented |
|---|
function GetAlignedMem(Size,Alignment:PtrUInt):Pointer;
Description: Allocate a block of normal memory aligned on a multiple of the alignment value
| Alignment | The alignment must be a multiple of the minimum alignment configuration |
|---|
function GetAlignedMemEx(Size,Alignment:PtrUInt; Flags,Affinity:LongWord):Pointer;
Description: Allocate a block of memory aligned on a multiple of the alignment value with the flags and affinity requested
| Alignment | The alignment must be a multiple of the minimum alignment configuration |
|---|
function GetSharedMem(Size:PtrUInt):Pointer;
Description: Allocate a block of shared memory
| Note | None documented |
|---|
function GetSharedAlignedMem(Size,Alignment:PtrUInt):Pointer;
Description: Allocate a block of shared memory aligned on a multiple of the alignment value
| Alignment | The alignment must be a multiple of the minimum alignment configuration |
|---|
function GetLocalMem(Size:PtrUInt; Affinity:LongWord):Pointer;
Description: Allocate a block of local memory
| Note | None documented |
|---|
function GetLocalAlignedMem(Size,Alignment:PtrUInt; Affinity:LongWord):Pointer;
Description: Allocate a block of local memory aligned on a multiple of the alignment value
| Alignment | The alignment must be a multiple of the minimum alignment configuration |
|---|
function GetCodeMem(Size:PtrUInt; Affinity:LongWord):Pointer;
Description: Allocate a block of code memory
| Note | None documented |
|---|
function GetCodeAlignedMem(Size,Alignment:PtrUInt; Affinity:LongWord):Pointer;
Description: Allocate a block of code memory aligned on a multiple of the alignment value
| Alignment | The alignment must be a multiple of the minimum alignment configuration |
|---|
function GetDeviceMem(Size:PtrUInt):Pointer;
Description: Allocate a block of device memory
| Note | None documented |
|---|
function GetDeviceAlignedMem(Size,Alignment:PtrUInt):Pointer;
Description: Allocate a block of device memory aligned on a multiple of the alignment value
| Alignment | The alignment must be a multiple of the minimum alignment configuration |
|---|
function GetNoCacheMem(Size:PtrUInt):Pointer;
Description: Allocate a block of non cached memory
| Note | None documented |
|---|
function GetNoCacheAlignedMem(Size,Alignment:PtrUInt):Pointer;
Description: Allocate a block of non cached memory aligned on a multiple of the alignment value
| Alignment | The alignment must be a multiple of the minimum alignment configuration |
|---|
function GetNonSharedMem(Size:PtrUInt):Pointer;
Description: Allocate a block of non shared memory
| Note | None documented |
|---|
function GetNonSharedAlignedMem(Size,Alignment:PtrUInt):Pointer;
Description: Allocate a block of non shared memory aligned on a multiple of the alignment value
| Alignment | The alignment must be a multiple of the minimum alignment configuration |
|---|
function GetIRQMem(Size:PtrUInt; Affinity:LongWord):Pointer;
Description: Allocate a block of IRQ memory
| Note | None documented |
|---|
function GetIRQAlignedMem(Size,Alignment:PtrUInt; Affinity:LongWord):Pointer;
Description: Allocate a block of IRQ memory aligned on a multiple of the alignment value
| Alignment | The alignment must be a multiple of the minimum alignment configuration |
|---|
function GetFIQMem(Size:PtrUInt; Affinity:LongWord):Pointer;
Description: Allocate a block of FIQ memory
| Note | None documented |
|---|
function GetFIQAlignedMem(Size,Alignment:PtrUInt; Affinity:LongWord):Pointer;
Description: Allocate a block of FIQ memory aligned on a multiple of the alignment value
| Alignment | The alignment must be a multiple of the minimum alignment configuration |
|---|
function FreeIRQMem(Addr:Pointer):PtrUInt;
Description: Free a block of IRQ memory
| Note | None documented |
|---|
function FreeFIQMem(Addr:Pointer):PtrUInt;
Description: Free a block of FIQ memory
| Note | None documented |
|---|
function AllocMemEx(Size:PtrUInt; Flags,Affinity:LongWord):Pointer;
Description: Allocate and clear a block of memory with the flags and affinity requested
| Note | None documented |
|---|
function ReAllocMemEx(var Addr:Pointer; Size:PtrUInt; Flags,Affinity:LongWord):Pointer;
Description: Reallocate a block of memory with the flags and affinity requested
| Note | None documented |
|---|
function AllocAlignedMem(Size,Alignment:PtrUInt):Pointer;
Description: Allocate and clear a block of normal memory aligned on a multiple of the alignment value
| Alignment | The alignment must be a multiple of the minimum alignment configuration |
|---|
function AllocAlignedMemEx(Size,Alignment:PtrUInt; Flags,Affinity:LongWord):Pointer;
Description: Allocate and clear a block of normal memory aligned on a multiple of the alignment value with the flags and affinity requested
| Alignment | The alignment must be a multiple of the minimum alignment configuration |
|---|
function ReAllocAlignedMem(var Addr:Pointer; Size,Alignment:PtrUInt):Pointer;
Description: Reallocate a block of normal memory aligned on a multiple of the alignment value
| Alignment | The alignment must be a multiple of the minimum alignment configuration |
|---|
function ReAllocAlignedMemEx(var Addr:Pointer; Size,Alignment:PtrUInt; Flags,Affinity:LongWord):Pointer;
Description: Reallocate a block of memory aligned on a multiple of the alignment value with the flags and affinity requested
| Alignment | The alignment must be a multiple of the minimum alignment configuration |
|---|
function AllocSharedMem(Size:PtrUInt):Pointer;
Description: Allocate and clear a block of shared memory
| Note | None documented |
|---|
function AllocSharedAlignedMem(Size,Alignment:PtrUInt):Pointer;
Description: Allocate and clear a block of shared memory aligned on a multiple of the alignment value
| Alignment | The alignment must be a multiple of the minimum alignment configuration |
|---|
function ReAllocSharedMem(var Addr:Pointer; Size:PtrUInt):Pointer;
Description: Reallocate a block of shared memory
| Note | None documented |
|---|
function ReAllocSharedAlignedMem(var Addr:Pointer; Size,Alignment:PtrUInt):Pointer;
Description: Reallocate a block of shared memory aligned on a multiple of the alignment value
| Alignment | The alignment must be a multiple of the minimum alignment configuration |
|---|
function AllocLocalMem(Size:PtrUInt; Affinity:LongWord):Pointer;
Description: Allocate and clear a block of local memory
| Note | None documented |
|---|
function AllocLocalAlignedMem(Size,Alignment:PtrUInt; Affinity:LongWord):Pointer;
Description: Allocate and clear a block of local memory aligned on a multiple of the alignment value
| Alignment | The alignment must be a multiple of the minimum alignment configuration |
|---|
function ReAllocLocalMem(var Addr:Pointer; Size:PtrUInt; Affinity:LongWord):Pointer;
Description: Reallocate a block of local memory
| Note | None documented |
|---|
function ReAllocLocalAlignedMem(var Addr:Pointer; Size,Alignment:PtrUInt; Affinity:LongWord):Pointer;
Description: Reallocate a block of local memory aligned on a multiple of the alignment value
| Alignment | The alignment must be a multiple of the minimum alignment configuration |
|---|
function AllocCodeMem(Size:PtrUInt; Affinity:LongWord):Pointer;
Description: Allocate and clear a block of code memory
| Note | None documented |
|---|
function AllocCodeAlignedMem(Size,Alignment:PtrUInt; Affinity:LongWord):Pointer;
Description: Allocate and clear a block of code memory aligned on a multiple of the alignment value
| Alignment | The alignment must be a multiple of the minimum alignment configuration |
|---|
function ReAllocCodeMem(var Addr:Pointer; Size:PtrUInt; Affinity:LongWord):Pointer;
Description: Reallocate a block of code memory
| Note | None documented |
|---|
function ReAllocCodeAlignedMem(var Addr:Pointer; Size,Alignment:PtrUInt; Affinity:LongWord):Pointer;
Description: Reallocate a block of code memory aligned on a multiple of the alignment value
| Alignment | The alignment must be a multiple of the minimum alignment configuration |
|---|
function AllocDeviceMem(Size:PtrUInt):Pointer;
Description: Allocate and clear a block of device memory
| Note | None documented |
|---|
function AllocDeviceAlignedMem(Size,Alignment:PtrUInt):Pointer;
Description: Allocate and clear a block of device memory aligned on a multiple of the alignment value
| Alignment | The alignment must be a multiple of the minimum alignment configuration |
|---|
function ReAllocDeviceMem(var Addr:Pointer; Size:PtrUInt):Pointer;
Description: Reallocate a block of device memory
| Note | None documented |
|---|
function ReAllocDeviceAlignedMem(var Addr:Pointer; Size,Alignment:PtrUInt):Pointer;
Description: Reallocate a block of device memory aligned on a multiple of the alignment value
| Alignment | The alignment must be a multiple of the minimum alignment configuration |
|---|
function AllocNoCacheMem(Size:PtrUInt):Pointer;
Description: Allocate and clear a block of non cached memory
| Note | None documented |
|---|
function AllocNoCacheAlignedMem(Size,Alignment:PtrUInt):Pointer;
Description: Allocate and clear a block of non cached memory aligned on a multiple of the alignment value
| Alignment | The alignment must be a multiple of the minimum alignment configuration |
|---|
function ReAllocNoCacheMem(var Addr:Pointer; Size:PtrUInt):Pointer;
Description: Reallocate a block of non cached memory
| Note | None documented |
|---|
function ReAllocNoCacheAlignedMem(var Addr:Pointer; Size,Alignment:PtrUInt):Pointer;
Description: Reallocate a block of non cached memory aligned on a multiple of the alignment value
| Alignment | The alignment must be a multiple of the minimum alignment configuration |
|---|
function AllocNonSharedMem(Size:PtrUInt):Pointer;
Description: Allocate and clear a block of non shared memory
| Note | None documented |
|---|
function AllocNonSharedAlignedMem(Size,Alignment:PtrUInt):Pointer;
Description: Allocate and clear a block of non shared memory aligned on a multiple of the alignment value
| Alignment | The alignment must be a multiple of the minimum alignment configuration |
|---|
function ReAllocNonSharedMem(var Addr:Pointer; Size:PtrUInt):Pointer;
Description: Reallocate a block of non shared memory
| Note | None documented |
|---|
function ReAllocNonSharedAlignedMem(var Addr:Pointer; Size,Alignment:PtrUInt):Pointer;
Description: Reallocate a block of non shared memory aligned on a multiple of the alignment value
| Alignment | The alignment must be a multiple of the minimum alignment configuration |
|---|
function AllocIRQMem(Size:PtrUInt; Affinity:LongWord):Pointer;
Description: Allocate and clear a block of IRQ memory
| Note | The memory must be freed using FreeIRQMem |
|---|
function AllocIRQAlignedMem(Size,Alignment:PtrUInt; Affinity:LongWord):Pointer;
Description: Allocate and clear a block of IRQ memory aligned on a multiple of the alignment value
| Alignment | The alignment must be a multiple of the minimum alignment configuration |
|---|---|
| Note | The memory must be freed using FreeIRQMem |
function ReAllocIRQMem(var Addr:Pointer; Size:PtrUInt; Affinity:LongWord):Pointer;
Description: Reallocate a block of IRQ memory
| Note | None documented |
|---|
function ReAllocIRQAlignedMem(var Addr:Pointer; Size,Alignment:PtrUInt; Affinity:LongWord):Pointer;
Description: Reallocate a block of IRQ memory aligned on a multiple of the alignment value
| Alignment | The alignment must be a multiple of the minimum alignment configuration |
|---|
function AllocFIQMem(Size:PtrUInt; Affinity:LongWord):Pointer;
Description: Allocate and clear a block of FIQ memory
| Note | The memory must be freed using FreeFIQMem |
|---|
function AllocFIQAlignedMem(Size,Alignment:PtrUInt; Affinity:LongWord):Pointer;
Description: Allocate and clear a block of FIQ memory aligned on a multiple of the alignment value
| Alignment | The alignment must be a multiple of the minimum alignment configuration |
|---|---|
| Note | The memory must be freed using FreeFIQMem |
function ReAllocFIQMem(var Addr:Pointer; Size:PtrUInt; Affinity:LongWord):Pointer;
Description: Reallocate a block of FIQ memory
| Note | None documented |
|---|
function ReAllocFIQAlignedMem(var Addr:Pointer; Size,Alignment:PtrUInt; Affinity:LongWord):Pointer;
Description: Reallocate a block of FIQ memory aligned on a multiple of the alignment value
| Alignment | The alignment must be a multiple of the minimum alignment configuration |
|---|
function SizeIRQMem(Addr:Pointer):PtrUInt;
Description: Return the size of an allocated block of IRQ memory
| Note | None documented |
|---|
function SizeFIQMem(Addr:Pointer):PtrUInt;
Description: Return the size of an allocated block of FIQ memory
| Note | None documented |
|---|
function MemFlags(Addr:Pointer):LongWord;
Description: Return the flags of an allocated block of memory
| Note | None documented |
|---|
function MemFlagsIRQ(Addr:Pointer):LongWord;
Description: Return the flags of an allocated block of IRQ memory
| Note | None documented |
|---|
function MemFlagsFIQ(Addr:Pointer):LongWord;
Description: Return the flags of an allocated block of FIQ memory
| Note | None documented |
|---|
function GetHeapStatistics:THeapStatistics;
Description: Return detailed statistics for the heap manager
| Note | None documented |
|---|
function GetHeapBlockCount(State:LongWord):LongWord;
Description: Get the total number of current heap blocks based on state
| Note | None documented |
|---|
function GetHeapBlockCountEx(State,Flags,Affinity:LongWord):LongWord;
Description: Get the number of current heap blocks based on state, flags and affinity
| Note | This uses the block list (not the Free/Used/Small lists) in order to account for all blocks |
|---|
function GetHeapBlockMin(State:LongWord):LongWord;
Description: Get the minimum size of current heap blocks based on state
| Note | None documented |
|---|
function GetHeapBlockMinEx(State,Flags,Affinity:LongWord):LongWord;
Description: Get the minimum size of current heap blocks based on state, flags and affinity
| Note | This uses the block list (not the Free/Used/Small lists) in order to account for all blocks |
|---|
function GetHeapBlockMax(State:LongWord):LongWord;
Description: Get the maximum size of current heap blocks based on state
| Note | None documented |
|---|
function GetHeapBlockMaxEx(State,Flags,Affinity:LongWord):LongWord;
Description: Get the maximum size of current heap blocks based on state, flags and affinity
| Note | This uses the block list (not the Free/Used/Small lists) in order to account for all blocks |
|---|
function CreateHeapSnapshot(State:LongWord):PHeapSnapshot;
Description: To be documented
| Note | None documented |
|---|
function CreateHeapSnapshotEx(State,Flags,Affinity:LongWord):PHeapSnapshot;
Description: To be documented
| Note | None documented |
|---|
function DestroyHeapSnapshot(Snapshot:PHeapSnapshot):LongWord;
Description: To be documented
| Note | None documented |
|---|
Internal functions
function GetHeapBlock(Address:Pointer):PHeapBlock;
Description: Get the Heap Block referenced by Address
| Note | Address has already been normalized to include the Heap Block. Caller must hold the heap lock. |
|---|
function FindHeapBlock(Address:Pointer; Size:PtrUInt):PHeapBlock;
Description: Find the Heap Block containing Address up to the Size specified
| Note | Address has already been normalized to include the Heap Block. Caller must hold the heap lock. |
|---|
function AddHeapBlock(Block:PHeapBlock):Boolean;
Description: Add a heap block, sorted by ascending Address order
| Note | Caller must hold the heap lock |
|---|
function SplitHeapBlock(Block:PHeapBlock; Size:PtrUInt):PHeapBlock;
Description: Split a heap block at the size indicated
| Return | Return The return is the split portion of the block |
|---|---|
| Note | Caller must remove block from the free list. Caller must add split block to the free list. Caller must hold the heap lock. |
function MergeHeapBlock(Block:PHeapBlock):PHeapBlock;
Description: Merge a heap block with Prev or Next blocks if free
| Return | The return is the merged result of the blocks |
|---|---|
| Note | Caller must remove block from the free list. Caller must add merged block to the free list. Caller must hold the heap lock. |
function GetFreeBlock(Size:PtrUInt):PHeapBlock;
Description: Get a free block of at least the size indicated
| Size | The size has already been normalized to alignment and includes the size of the Heap Block |
|---|---|
| Note | Caller must hold the heap lock |
function GetFreeBlockEx(Size:PtrUInt; Flags,Affinity:LongWord):PHeapBlock;
Description: Get a free block of at least the size indicated with the flags and affinity requested
| Size | The size has already been normalized to alignment and includes the size of the Heap Block |
|---|---|
| Note | Caller must hold the heap lock |
function FindFreeBlock(Size:PtrUInt):PHeapBlock;
Description: Find a free block of at least the size indicated with no flags or affinity which is alignable to the HEAP_REQUEST_ALIGNMENT value
| Size | The size is the exact size and has not been normalized |
|---|---|
| Note | Caller must hold the heap lock |
function AddFreeBlock(Block:PHeapBlock):Boolean;
Description: Add a free block, sorted by ascending Size order
| Note | Caller must hold the heap lock |
|---|
function RemoveFreeBlock(Block:PHeapBlock):Boolean;
Description: Remove a free block
| Note | Caller must hold the heap lock |
|---|
function GetUsedBlock(Address:Pointer):PHeapBlock;
Description: Get a used block by address
| Address | The address has already been normalized to include the Heap Block |
|---|---|
| Note | Caller must hold the heap lock |
function CheckUsedBlock(Address:Pointer):Boolean; inline;
Description: Check a used block by address
| Address | The address has already been normalized to include the Heap Block |
|---|---|
| Note | Caller must hold the heap lock |
function AddUsedBlock(Block:PHeapBlock):Boolean;
Description: Add a used block
| Note | Caller must hold the heap lock |
|---|
function RemoveUsedBlock(Block:PHeapBlock):Boolean;
Description: Remove a used block
| Note | Caller must hold the heap lock |
|---|
function GetIRQBlock(Address:Pointer):PHeapBlock;
Description: Get the IRQ Heap Block referenced by Address
| Address | The address has already been normalized to include the IRQ Heap Block |
|---|---|
| Note | Caller must hold the IRQ heap lock |
function CheckIRQBlock(Address:Pointer):Boolean;
Description: Check the IRQ Heap Block referenced by Address
| Address | The address has already been normalized to include the IRQ Heap Block |
|---|---|
| Note | Caller must hold the IRQ heap lock |
function AddIRQBlock(Block:PHeapBlock):Boolean;
Description: Add an IRQ heap block, sorted by ascending Address order
| Note | Caller must hold the IRQ heap lock |
|---|
function SplitIRQBlock(Block:PHeapBlock; Size:PtrUInt):PHeapBlock;
Description: Split an IRQ heap block at the size indicated
| Return | The return is the split portion of the block |
|---|---|
| Note | Caller must remove block from the IRQ free list. Caller must add split block to the IRQ free list. Caller must hold the IRQ heap lock. |
function MergeIRQBlock(Block:PHeapBlock):PHeapBlock;
Description: Merge an IRQ heap block with Prev or Next blocks if free
| Return | The return is the merged result of the blocks |
|---|---|
| Note | Caller must remove block from the IRQ free list. Caller must add merged block to the IRQ free list. Caller must hold the IRQ heap lock. |
function GetFreeIRQBlock(Size:PtrUInt; Affinity:LongWord):PHeapBlock;
Description: Get a free IRQ block of at least the size indicated
| Size | The size has already been normalized to alignment and includes the size of the IRQ Heap Block |
|---|---|
| Note | Caller must hold the IRQ heap lock |
function AddFreeIRQBlock(Block:PHeapBlock):Boolean;
Description: Add a free IRQ block, sorted by ascending Size order
| Note | Caller must hold the IRQ heap lock |
|---|
function RemoveFreeIRQBlock(Block:PHeapBlock):Boolean;
Description: Remove a free IRQ block
| Note | Caller must hold the IRQ heap lock |
|---|
function GetFIQBlock(Address:Pointer):PHeapBlock;
Description: Get the FIQ Heap Block referenced by Address
| Address | The address has already been normalized to include the FIQ Heap Block |
|---|---|
| Note | Caller must hold the FIQ heap lock |
function CheckFIQBlock(Address:Pointer):Boolean;
Description: Check the FIQ Heap Block referenced by Address
| Address | The address has already been normalized to include the FIQ Heap Block |
|---|---|
| Note | Caller must hold the FIQ heap lock |
function AddFIQBlock(Block:PHeapBlock):Boolean;
Description: Add an FIQ heap block, sorted by ascending Address order
| Note | Caller must hold the FIQ heap lock |
|---|
function SplitFIQBlock(Block:PHeapBlock; Size:PtrUInt):PHeapBlock;
Description: Split an FIQ heap block at the size indicated
| Return | The return is the split portion of the block |
|---|---|
| Note | Caller must remove block from the FIQ free list. Caller must add split block to the FIQ free list. Caller must hold the FIQ heap lock. |
function MergeFIQBlock(Block:PHeapBlock):PHeapBlock;
Description: Merge an FIQ heap block with Prev or Next blocks if free
| Return | The return is the merged result of the blocks |
|---|---|
| Note | Caller must remove block from the FIQ free list. Caller must add merged block to the FIQ free list. Caller must hold the FIQ heap lock. |
function GetFreeFIQBlock(Size:PtrUInt; Affinity:LongWord):PHeapBlock;
Description: Get a free FIQ block of at least the size indicated
| Size | The size has already been normalized to alignment and includes the size of the FIQ Heap Block |
|---|---|
| Note | Caller must hold the FIQ heap lock |
function AddFreeFIQBlock(Block:PHeapBlock):Boolean;
Description: Add a free FIQ block, sorted by ascending Size order
| Note | Caller must hold the FIQ heap lock |
|---|
function RemoveFreeFIQBlock(Block:PHeapBlock):Boolean;
Description: Remove a free FIQ block
| Note | Caller must hold the FIQ heap lock |
|---|
RTL heap manager functions
function SysGetMem(Size:PtrUInt):Pointer;
Description: Allocate a block of normal memory
| Note | None documented |
|---|
function SysFreeMem(Addr:Pointer):PtrUInt;
Description: Free a block of memory
| Note | None documented |
|---|
function SysFreeMemSize(Addr:Pointer; Size:PtrUInt):PtrUInt;
Description: Free a block of memory
| Note | Size is not currently used |
|---|
function SysAllocMem(Size:PtrUInt):Pointer;
Description: Allocate and clear a block of normal memory
| Note | None documented |
|---|
function SysReAllocMem(var Addr:Pointer; Size:PtrUInt):Pointer;
Description: Reallocate a block of normal memory
| Note | None documented |
|---|
function SysSizeMem(Addr:Pointer):PtrUInt;
Description: Return the size of an allocated block of memory
| Note | None documented |
|---|
procedure SysInitThread;
Description: Initialize thread specific heap information
| Note | None documented |
|---|
procedure SysDoneThread;
Description: Finalize thread specific heap information
| Note | None documented |
|---|
procedure SysRelocateHeap;
Description: Relocate heap data
| Note | None documented |
|---|
function SysGetHeapStatus:THeapStatus;
Description: Return status information for the heap manager
| Note | None documented |
|---|
function SysGetFPCHeapStatus:TFPCHeapStatus;
Description: Return status information for the heap manager
| Note | None documented |
|---|
Helper functions
procedure AcquireHeapLock; inline;
Description: To be documented
| Note | None documented |
|---|
procedure ReleaseHeapLock; inline;
Description: To be documented
| Note | None documented |
|---|
procedure AcquireHeapIRQLock; inline;
Description: To be documented
| Note | None documented |
|---|
procedure ReleaseHeapIRQLock; inline;
Description: To be documented
| Note | None documented |
|---|
procedure AcquireHeapFIQLock; inline;
Description: To be documented
| Note | None documented |
|---|
procedure ReleaseHeapFIQLock; inline;
Description: To be documented
| Note | None documented |
|---|
procedure RegisterHeapLock(const Lock:THeapLock);
Description: To be documented
| Note | None documented |
|---|
function HeapStateToString(State:LongWord):String;
Description: To be documented
| Note | None documented |
|---|
Return to Unit Reference
