cammemory.cpp File Reference

(r1785/r1492)

#include "camtypes.h"
#include <stdio.h>

Go to the source code of this file.

Classes
class	DynamicHeap
Defines
#define	new   CAM_DEBUG_NEW
Functions
	DECLARE_SOURCE ("$Revision: 1492 $")
static DynamicHeap *	FindHeap (MHANDLE Handle)
	This function works out which heap the block associated with the handle is in.
BOOL	InitMemory ()
	Initialises the dynamic memory manager. This involves obtaining a block of memory from the OS. This is then used as a pool to satisfy allocation requests from clients of this module.
void	DeinitMemory ()
	Returns the memory pool to the OS.
MHANDLE	ClaimBlock (size_t Size, BOOL Heavy)
	Allocates a block of 'size' bytes from the free pool, and obtains a handle or it. Blocks which are zero bytes long are permitted, but blocks must be word-sized (i.e. a multiple of 4 bytes in size).
BOOL	ReleaseBlock (MHANDLE Handle)
	Given a handle to a memory block, releases this memory block from use, and returns the block to the free pool. Subsequent accesses via this handle or via the block's address cause undefined behaviour.
BOOL	DescribeBlock (MHANDLE Handle, ADDR *Address, size_t *Size)
	Given a handle, returns the size and location of the associated block of memory.
BOOL	SplitBlock (MHANDLE Handle, INT32 SplitSize, UINT32 Offset)
	NB. Do not use this function! Use on of the following instead: IncreaseBlock, DecreaseBlock.
BOOL	IncreaseBlock (MHANDLE Handle, UINT32 NumBytes)
	Increase the size of the specified block by the specified amount. No memory is moved within the block - the block is simply extended. NB. This operation may cause the block to move, so the handle should be realised into an address again (via DescribeBlock()) after this function returns.
BOOL	DecreaseBlock (MHANDLE Handle, UINT32 NumBytes)
	Decrease the size of the specified block by the specified amount. No memory is moved within the block - the block is simply reduced in size, and the memory is chopped off the end. NB. This operation may cause the block to move, so the handle should be realised into an address again (via DescribeBlock()) after this function returns.
BOOL	InsertMemory (MHANDLE Handle, UINT32 Offset, UINT32 NumBytes)
	Insert memory into the middle of a block at the position specified by the 'Offset' parameter. The memory above the offset is shuffled up (i.e. it is not overwritten). i.e. the 'B' block is moved up in order to insert the new memory. The new memory (the '?' block) is uninitialised, so you must initialise it yourself.
BOOL	RemoveMemory (MHANDLE Handle, UINT32 Offset, UINT32 NumBytes)
	Remove memory from the middle of a block at the position specified by the 'Offset' parameter. The memory contents above the offset is shuffled down (i.e. it is not lost). i.e. the 'B' block is moved down in order to preserve its contents. The 'A' block is truncated, and the last 'NumBytes' of it are lost.
BOOL	TidyMemory ()
	Removes one hole from the heap (if any exist). It always removes the hole which is lowest in memory in an attempt to avoid redundant memory moves. Intended to be called on idle events to sanitise the heap when nothing much else is going on.
void	GetMemoryStatus (UINT64 *pPhysRam, UINT32 *pLoadPercent)
	Read the current state of the memory environment for Camelot.
Variables
static DynamicHeap *	NormalHeap = NULL

---

Define Documentation

#define new   CAM_DEBUG_NEW

Definition at line 123 of file cammemory.cpp.

---

Function Documentation

MHANDLE ClaimBlock (  size_t  Size, BOOL  Heavy )

Allocates a block of 'size' bytes from the free pool, and obtains a handle or it. Blocks which are zero bytes long are permitted, but blocks must be word-sized (i.e. a multiple of 4 bytes in size). Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 26/4/93 Parameters: Size,:  The size in bytes of the block being requested [INPUTS] Heavy: If TRUE, then the block is treated differently to other (non-heavy) blocks, in that heavy blocks are the last to be moved. Large objects (e.g. bitmaps etc) should be declared heavy. Returns: The handle that refers to the newly allocated block. Definition at line 670 of file cammemory.cpp. { // Make sure we have a heap if (NormalHeap==NULL) { ERROR3("The Heap is not there!"); return BAD_MHANDLE; } // claim some memory from it return NormalHeap->ClaimBlock(Size); }

DECLARE_SOURCE (  "$Revision: 1492 $"   )

BOOL DecreaseBlock (  MHANDLE  Handle, UINT32  NumBytes )

Decrease the size of the specified block by the specified amount. No memory is moved within the block - the block is simply reduced in size, and the memory is chopped off the end. NB. This operation may cause the block to move, so the handle should be realised into an address again (via DescribeBlock()) after this function returns. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 06/12/93 Parameters: Handle  - the handle of the block to resize [INPUTS] NumBytes - the number of bytes to remove from this block's allocation (must be word-sized, and >=12 bytes). Returns: TRUE if the resize worked, FALSE if it failed. See also: IncreaseBlock; InsertMemory; RemoveMemory; DescribeHandle Definition at line 825 of file cammemory.cpp. { // Make sure we have a heap if (NormalHeap==NULL) { ERROR3("The Heap is not there!"); return FALSE; } // Decrease the block return NormalHeap->DecreaseBlock(Handle, NumBytes); }

void DeinitMemory (   )

Returns the memory pool to the OS. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 26/4/93 Definition at line 647 of file cammemory.cpp. { if (NormalHeap != NULL) delete NormalHeap; }

BOOL DescribeBlock (  MHANDLE  Handle, ADDR *  Address, size_t *  Size )

Given a handle, returns the size and location of the associated block of memory. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 26/4/93 Parameters: Handle,:  The handle of the block to describe [INPUTS] Address,:  The real address of the block [OUTPUTS] Size: The size in bytes of the block Returns: TRUE if the handle was valid Definition at line 727 of file cammemory.cpp. { // Get details associated with this handle *Address = DescribeHandle(Handle); if (*Address == NULL) { // Handle was invalid - return error TRACE( wxT("DescribeBlock: Handle is invalid\n") ); *Address = NULL; *Size = 0; return FALSE; } // Extract the size from the block *Size = CCGetBlockSize(*Address); // Everything went ok return TRUE; }

static DynamicHeap* FindHeap (  MHANDLE  Handle  )  [inline, static]

This function works out which heap the block associated with the handle is in. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 09/02/94 Parameters: Handle  - the handle of the block to look for. [INPUTS] Returns: Pointer to the heap containing the block identified by 'Handle', or NULL if the block cannot be found. Definition at line 592 of file cammemory.cpp. { ADDR Address = DescribeHandle(Handle); if (Address != BAD_MHANDLE) { // return the heap return NormalHeap; } // Couldn't find the correct heap return NULL; }

void GetMemoryStatus (  UINT64 *  pPhysRam, UINT32 *  pLoadPercent )

Read the current state of the memory environment for Camelot. Author: Phil_Martin (Xara Group Ltd) <camelotdev@xara.com> Date: 09/March/2006 Parameters: -  [INPUTS] Ouputs: PhysRam - Amount of physical RAM (in bytes) CurrentLoadPercent - Percentage of physical RAM in use at the time of this call Returns: - Definition at line 981 of file cammemory.cpp. { #if defined(__WXMSW__) // Windows: // It's important to call GlobalMemoryStatusEX if it's available // because GlobalMemoryStatus has issues in older OSs that can cause it to return // duff information. GETMEMORYSTATUSEX_FUNC pExFunc; pExFunc = (GETMEMORYSTATUSEX_FUNC) GetProcAddress(GetModuleHandle(_T("kernel32.dll")), "GlobalMemoryStatusEx"); if (pExFunc) { MEMORYSTATUSEX memStatus; memStatus.dwLength=sizeof(MEMORYSTATUSEX); pExFunc(&memStatus); if (pLoadPercent) *pLoadPercent = memStatus.dwMemoryLoad; if (pPhysRam) *pPhysRam = memStatus.ullTotalPhys; } else { MEMORYSTATUS memStatus; memStatus.dwLength=sizeof(MEMORYSTATUS); GlobalMemoryStatus(&memStatus); if (pLoadPercent) *pLoadPercent = memStatus.dwMemoryLoad; if (pPhysRam) *pPhysRam = memStatus.dwTotalPhys; } #elsif defined(__WXGTK__) // Assume Linux - there should really be some FreeBSD code here /* Linux: read memory information from the kernel's /proc/meminfo interface */ FILE *fp; unsigned long /*TYPENOTE: Correct*/ memTotalKb, memFreeKb; int /*TYPENOTE: Correct*/ haveMemTotal = 0, haveMemFree = 0; char lineBuf[256]; fp = fopen("/proc/meminfo", "r"); if (fp != NULL) { while (!haveMemTotal || !haveMemFree) { if (fgets(lineBuf, 256, fp) == NULL) break; if (sscanf(lineBuf, "MemTotal: %lu", &memTotalKb) == 1) haveMemTotal = 1; if (sscanf(lineBuf, "MemFree: %lu", &memFreeKb) == 1) haveMemFree = 1; } fclose(fp); } if (!haveMemTotal) memTotalKb = 512UL * 1024; /* guess 512MB */ if (!haveMemFree) memFreeKb = memTotalKb / 2; /* guess 50% free */ if (pPhysRam != NULL) *pPhysRam = (UINT64)memTotalKb * 1024; if (pLoadPercent != NULL) *pLoadPercent = (UINT32)(100UL - ((memFreeKb * 100UL) / memTotalKb)); #else PORTNOTETRACE("other", "GetMemoryStatus is not implemented on this architecture"); if (pPhysRam) *pPhysRam = 512L * 1024 * 1024; // Guess 512M if (pLoadPercent) *pLoadPercent = 50; // Guess 50% free #endif }

BOOL IncreaseBlock (  MHANDLE  Handle, UINT32  NumBytes )

Increase the size of the specified block by the specified amount. No memory is moved within the block - the block is simply extended. NB. This operation may cause the block to move, so the handle should be realised into an address again (via DescribeBlock()) after this function returns. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 06/12/93 Parameters: Handle  - the handle of the block to resize [INPUTS] NumBytes - the number of bytes to add to this block's allocation (must be word-sized, and >=12 bytes). Returns: TRUE if the resize worked, FALSE if it failed. See also: DecreaseBlock; InsertMemory; RemoveMemory; DescribeHandle Definition at line 792 of file cammemory.cpp. { // Make sure we have a heap if (NormalHeap==NULL) { ERROR3("The Heap is not there!"); return FALSE; } // Increase the block return NormalHeap->IncreaseBlock(Handle, NumBytes); }

BOOL InitMemory (   )

Initialises the dynamic memory manager. This involves obtaining a block of memory from the OS. This is then used as a pool to satisfy allocation requests from clients of this module. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 26/4/93 Returns: TRUE if global memory was obtained and initialised successfully. Definition at line 620 of file cammemory.cpp. { // Initialise the two heaps - one for normal objects, one for hevy objects (bitmaps etc) NormalHeap = new DynamicHeap; if (NormalHeap==NULL) return FALSE; if (!NormalHeap->Init()) // report failure of heap initialisation return FALSE; // Everything went ok return TRUE; }

BOOL InsertMemory (  MHANDLE  Handle, UINT32  Offset, UINT32  NumBytes )

Insert memory into the middle of a block at the position specified by the 'Offset' parameter. The memory above the offset is shuffled up (i.e. it is not overwritten). i.e. the 'B' block is moved up in order to insert the new memory. The new memory (the '?' block) is uninitialised, so you must initialise it yourself. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 06/12/93 Parameters: Handle  - the handle of the block to resize. [INPUTS] Offset - the position within the block to insert the memory at (must be word-aligned). NumBytes - the number of bytes to add to this block's allocation (must be word-sized, and >=12 bytes). Returns: TRUE, if the insertion was successful, FALSE if not. See also: IncreaseBlock; DecreaseBlock; RemoveMemory; DescribeHandle; DynamicHeap::InsertMemory Definition at line 862 of file cammemory.cpp. { ERROR3("InsertMemory function is now dead. Use IncreaseBlock or DecreaseBlock instead\n"); return FALSE; }

BOOL ReleaseBlock (  MHANDLE  Handle  )

Given a handle to a memory block, releases this memory block from use, and returns the block to the free pool. Subsequent accesses via this handle or via the block's address cause undefined behaviour. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 26/4/93 Parameters: Handle,:  The handle of the block to be released. [INPUTS] Returns: TRUE if the handle was valid Definition at line 697 of file cammemory.cpp. { // Make sure we have a heap if (NormalHeap==NULL) { ERROR3("The Heap is not there!"); return FALSE; } // Release the memory return NormalHeap->ReleaseBlock(Handle); }

BOOL RemoveMemory (  MHANDLE  Handle, UINT32  Offset, UINT32  NumBytes )

Remove memory from the middle of a block at the position specified by the 'Offset' parameter. The memory contents above the offset is shuffled down (i.e. it is not lost). i.e. the 'B' block is moved down in order to preserve its contents. The 'A' block is truncated, and the last 'NumBytes' of it are lost. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 06/12/93 Parameters: Handle  - the handle of the block to resize. [INPUTS] Offset - the position within the block to remove the memory at (must be word-aligned). NumBytes - the number of bytes to remove to this block's allocation (must be word-sized, and >=12 bytes). Returns: TRUE, if the removal was successful, FALSE if not. See also: IncreaseBlock; DecreaseBlock; InsertMemory; DescribeHandle; DynamicHeap::RemoveMemory Definition at line 891 of file cammemory.cpp. { ERROR3("RemoveMemory function is now dead. Use IncreaseBlock or DecreaseBlock instead\n"); return FALSE; }

BOOL SplitBlock (  MHANDLE  Handle, INT32  SplitSize, UINT32  Offset )

NB. Do not use this function! Use on of the following instead: IncreaseBlock, DecreaseBlock. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 26/4/93 Parameters: Handle,:  The handle of the block to be shrunk/enlarged. [INPUTS] SplitSize: Amount of memory to insert/delete. Offset: The position to insert/delete memory at. Returns: FALSE See also: IncreaseBlock; DecreaseBlock Definition at line 765 of file cammemory.cpp. { ERROR3("SplitBlock function is now dead. Use IncreaseBlock or DecreaseBlock instead\n"); return FALSE; }

BOOL TidyMemory (   )

Removes one hole from the heap (if any exist). It always removes the hole which is lowest in memory in an attempt to avoid redundant memory moves. Intended to be called on idle events to sanitise the heap when nothing much else is going on. Author: Tim_Browse (Xara Group Ltd) <camelotdev@xara.com> Date: 09/02/94 Returns: TRUE if a hole was removed, FALSE if there were no holes left to remove. Definition at line 911 of file cammemory.cpp. { return FALSE; }

---

Variable Documentation

DynamicHeap* NormalHeap = NULL [static]

Definition at line 325 of file cammemory.cpp.

---