| /**************************************************************/ | |
| /* ********************************************************** */ | |
| /* * * */ | |
| /* * DYNAMIC MEMORY MANAGEMENT MODULE * */ | |
| /* * * */ | |
| /* * $Module: MEMORY * */ | |
| /* * * */ | |
| /* * Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001 * */ | |
| /* * MPI fuer Informatik * */ | |
| /* * * */ | |
| /* * This program is free software; you can redistribute * */ | |
| /* * it and/or modify it under the terms of the GNU * */ | |
| /* * General Public License as published by the Free * */ | |
| /* * Software Foundation; either version 2 of the License, * */ | |
| /* * or (at your option) any later version. * */ | |
| /* * * */ | |
| /* * This program is distributed in the hope that it will * */ | |
| /* * be useful, but WITHOUT ANY WARRANTY; without even * */ | |
| /* * the implied warranty of MERCHANTABILITY or FITNESS * */ | |
| /* * FOR A PARTICULAR PURPOSE. See the GNU General Public * */ | |
| /* * License for more details. * */ | |
| /* * * */ | |
| /* * You should have received a copy of the GNU General * */ | |
| /* * Public License along with this program; if not, write * */ | |
| /* * to the Free Software Foundation, Inc., 59 Temple * */ | |
| /* * Place, Suite 330, Boston, MA 02111-1307 USA * */ | |
| /* * * */ | |
| /* * * */ | |
| /* $Revision$ * */ | |
| /* $State$ * */ | |
| /* $Date$ * */ | |
| /* $Author$ * */ | |
| /* * * */ | |
| /* * Contact: * */ | |
| /* * Christoph Weidenbach * */ | |
| /* * MPI fuer Informatik * */ | |
| /* * Stuhlsatzenhausweg 85 * */ | |
| /* * 66123 Saarbruecken * */ | |
| /* * Email: weidenb@mpi-sb.mpg.de * */ | |
| /* * Germany * */ | |
| /* * * */ | |
| /* ********************************************************** */ | |
| /**************************************************************/ | |
| /* $RCSfile$ */ | |
| #ifndef _MEMORY_ | |
| #define _MEMORY_ | |
| /**************************************************************/ | |
| /* Includes */ | |
| /**************************************************************/ | |
| #include "misc.h" | |
| /**************************************************************/ | |
| /* Data structures and constants */ | |
| /**************************************************************/ | |
| #ifndef memory__DYNMAXSIZE | |
| #define memory__DYNMAXSIZE 1024 /* At most blocks of size memory__DYNMAXSIZE | |
| bytes are administrated by the | |
| module, larger requests are | |
| directly mapped to system calls */ | |
| #endif | |
| #ifndef memory__SHAREDPAGES | |
| #define memory__SHAREDPAGES 1 /* Number of block sizes sharing an allocated | |
| page. By setting memory__SHAREDPAGES to 4, | |
| the module would administrate requests | |
| for 1, 2, 3 and 4 bytes on the same set of | |
| pages, requests for 5, 6, 7 and 8 on another | |
| one, etc. By default every block size has | |
| its own set of pages */ | |
| #endif | |
| #ifndef memory__FREESHREDDER | |
| #define memory__FREESHREDDER 'S' /* The decimal number 83, which can also be | |
| read as 53 hexadecimal, or the character | |
| 'S' in ASCII code */ | |
| #endif | |
| #define memory__KILOBYTE 1024 | |
| #ifndef memory__DEFAULTPAGESIZE | |
| #define memory__DEFAULTPAGESIZE (8 * memory__KILOBYTE) | |
| /* Used to set the default size of a page. | |
| If the default page size is too small to | |
| contain two objects of size memory__DYNMAXSIZE | |
| the default page size is automatically | |
| increased by the function memory_Init */ | |
| #endif | |
| #ifndef memory__UNLIMITED | |
| #define memory__UNLIMITED (-1) | |
| /* Used to set the maximal amount of memory | |
| available for the memory module to | |
| "unlimited" when calling memory_Init. */ | |
| #endif | |
| typedef struct MEMORY_RESOURCEHELP { | |
| POINTER free; /* pointer to the next free block in list */ | |
| POINTER next; /* pointer to the next fresh block */ | |
| POINTER page; /* pointer to head of page list */ | |
| POINTER end_of_page; /* pointer to the end of current page */ | |
| int total_size; /* total block size inc. debug marks */ | |
| int aligned_size; /* block size without debug marks */ | |
| int offset; /* offset of last usable block on page */ | |
| } MEMORY_RESOURCE; | |
| extern MEMORY_RESOURCE * memory_ARRAY[]; | |
| #if defined(CHECK) | |
| typedef struct MEMORY_INFOHELP { | |
| const char * mallocInFile; /* origin of allocation request: file */ | |
| const char * freeInFile; /* origin of deallocation request: file */ | |
| unsigned short int mallocAtLine; /* origin of allocation request: line */ | |
| unsigned short int freeAtLine; /* origin of deallocation request: line */ | |
| } MEMORY_INFONODE, * MEMORY_INFO; | |
| #endif | |
| typedef struct MEMORY_BIGBLOCKHEADERHELP { | |
| struct MEMORY_BIGBLOCKHEADERHELP * previous, * next; | |
| } MEMORY_BIGBLOCKHEADERNODE, * MEMORY_BIGBLOCKHEADER; | |
| extern long memory_MAXMEM; | |
| extern unsigned long memory_NEWBYTES; | |
| extern unsigned long memory_FREEDBYTES; | |
| extern const unsigned int memory_MAGICMALLOC; | |
| extern const unsigned int memory_MAGICFREE; | |
| extern const unsigned int memory_ALIGN; | |
| extern MEMORY_BIGBLOCKHEADER memory_BIGBLOCKS; | |
| /**************************************************************/ | |
| /* Debug Information */ | |
| /**************************************************************/ | |
| extern unsigned int memory_MARKSIZE; | |
| extern unsigned int memory_OFFSET; | |
| /**************************************************************/ | |
| /* Check Functions */ | |
| /**************************************************************/ | |
| #ifdef __cplusplus | |
| extern "C" { | |
| #endif | |
| #ifdef CHECK | |
| void memory_CheckFree(POINTER Freepointer, unsigned int Size, unsigned int RealBlockSize, const char * File, unsigned short int Line); | |
| #endif /* CHECK */ | |
| #ifdef __cplusplus | |
| } | |
| #endif | |
| /**************************************************************/ | |
| /* Inline Functions */ | |
| /**************************************************************/ | |
| static __inline__ unsigned int memory_CalculateRealBlockSize(unsigned int | |
| BlockSize) | |
| /********************************************************** | |
| INPUT : Size of a block of memory. | |
| RETURNS: its real size. | |
| SUMMARY: Calculates the size of a memory block, | |
| including padding due to memory alignment and | |
| page sharing | |
| **********************************************************/ | |
| { | |
| unsigned int RealSize; | |
| RealSize = BlockSize; | |
| if (RealSize % memory__SHAREDPAGES) { | |
| RealSize += memory__SHAREDPAGES - (RealSize % memory__SHAREDPAGES); | |
| } | |
| if (RealSize % memory_ALIGN) { | |
| RealSize += memory_ALIGN - (RealSize % memory_ALIGN); | |
| } | |
| return RealSize; | |
| } | |
| static __inline__ unsigned int memory_LookupRealBlockSize(unsigned int | |
| BlockSize) | |
| /********************************************************** | |
| INPUT : Size of a block of memory. | |
| RETURNS: its real size. | |
| SUMMARY: Returns the size of a memory block, | |
| including padding due to memory alignment and | |
| page sharing. | |
| **********************************************************/ | |
| { | |
| unsigned int RealSize; | |
| if (BlockSize < memory__DYNMAXSIZE) { | |
| RealSize = memory_ARRAY[BlockSize]->aligned_size; | |
| } | |
| else { | |
| RealSize = memory_CalculateRealBlockSize(BlockSize); | |
| } | |
| return RealSize; | |
| } | |
| #ifdef CHECK | |
| static __inline__ void memory_SetBlockStatusAndSize(POINTER Mem, | |
| unsigned int Status, | |
| unsigned int Size) | |
| /********************************************************** | |
| INPUT : a pointer to a block of memory, its status | |
| (memory_MAGICMALLOC or memory_MAGICFREE), and | |
| size. | |
| RETURNS: None. | |
| SUMMARY: Sets a status flag (memory_MAGICMALLOC or | |
| memory_MAGICFREE) and block size. | |
| **********************************************************/ | |
| { | |
| *((int *)Mem - 1) = Size; | |
| *((int *)((char *)Mem + memory_LookupRealBlockSize(Size))) = Status; | |
| } | |
| static __inline__ unsigned int memory_GetBlockSize(POINTER Mem) | |
| /********************************************************** | |
| INPUT : A pointer to a block of memory. | |
| RETURNS: its size. | |
| SUMMARY: Returns the size of a memory block. | |
| **********************************************************/ | |
| { | |
| return *((int *)Mem - 1); | |
| } | |
| static __inline__ unsigned int memory_GetRealBlockSize(POINTER Mem) | |
| /********************************************************** | |
| INPUT : A pointer to a block of memory. | |
| RETURNS: its real size. | |
| SUMMARY: Returns the real size of a memory block, | |
| including padding bytes. | |
| **********************************************************/ | |
| { | |
| return memory_LookupRealBlockSize(memory_GetBlockSize(Mem)); | |
| } | |
| static __inline__ unsigned int memory_GetBlockStatus(POINTER Mem) | |
| /********************************************************** | |
| INPUT : A pointer to a block of memory. | |
| RETURNS: its status. | |
| SUMMARY: Returns the status of a memory block. | |
| **********************************************************/ | |
| { | |
| unsigned int Size; | |
| Size = memory_GetBlockSize(Mem); | |
| return *((int *)((char *)Mem + memory_LookupRealBlockSize(Size))); | |
| } | |
| static __inline__ void memory_SetInfo(MEMORY_INFO Info, | |
| const char * MallocInFile, | |
| unsigned short int MallocAtLine, | |
| const char * FreeInFile, | |
| unsigned short int FreeAtLine) | |
| /********************************************************** | |
| INPUT : a memory info structure, strings for files where | |
| the block was allocated and freed, and short | |
| integers for the corresponding lines. | |
| RETURNS: None. | |
| SUMMARY: Sets the debugging information for a memory block | |
| **********************************************************/ | |
| { | |
| if (!Info) { | |
| misc_StartErrorReport(); | |
| misc_ErrorReport("\n In memory_SetInfo:"); | |
| misc_ErrorReport("\n Memory Error. Info is a NULL pointer.\n"); | |
| misc_FinishErrorReport(); | |
| } | |
| Info->mallocAtLine = MallocAtLine; | |
| Info->mallocInFile = MallocInFile; | |
| Info->freeAtLine = FreeAtLine; | |
| Info->freeInFile = FreeInFile; | |
| } | |
| #endif | |
| static __inline__ unsigned long memory_DemandedBytes(void) | |
| /********************************************************** | |
| INPUT : Nothing. | |
| RETURNS: Maximum number of bytes allocated at the same | |
| time by the module. | |
| SUMMARY: Returns maximum number of allocated bytes at the | |
| same time. | |
| **********************************************************/ | |
| { | |
| return memory_NEWBYTES; | |
| } | |
| static __inline__ unsigned long memory_UsedBytes(void) | |
| /********************************************************** | |
| INPUT : Nothing. | |
| RETURNS: Number of bytes currently in use by your program. | |
| SUMMARY: Returns number of bytes currently allocated. | |
| **********************************************************/ | |
| { | |
| return memory_NEWBYTES-memory_FREEDBYTES; | |
| } | |
| #ifdef NO_MEMORY_MANAGEMENT | |
| static __inline__ void memory_Free(POINTER Freepointer, unsigned int Size) | |
| { | |
| free((char*)Freepointer); | |
| } | |
| #else | |
| #ifdef CHECK | |
| static __inline__ void memory_FreeIntern(POINTER Freepointer, | |
| unsigned int Size, | |
| const char * File, | |
| unsigned short int Line) | |
| #else | |
| static __inline__ void memory_Free(POINTER Freepointer, unsigned int Size) | |
| #endif | |
| /********************************************************** | |
| INPUT : Pointer to the block of memory to be freed, | |
| and the block's size | |
| RETURNS: Nothing. | |
| SUMMARY: Frees a block of memory for reallocation. | |
| This function performs correctness checks | |
| in debugging mode. | |
| **********************************************************/ | |
| { | |
| unsigned int RealBlockSize; /* block´s alignment correct size */ | |
| RealBlockSize = memory_LookupRealBlockSize(Size); | |
| #ifdef CHECK | |
| memory_CheckFree(Freepointer, Size, RealBlockSize, File, Line); | |
| #endif | |
| /* Check if current block is a big block */ | |
| if (Size >= memory__DYNMAXSIZE) { | |
| /* if that´s true, remove it from the double linked big block list */ | |
| MEMORY_BIGBLOCKHEADER BigBlockHeader; | |
| BigBlockHeader = | |
| (MEMORY_BIGBLOCKHEADER) ((char *) Freepointer - memory_OFFSET | |
| - sizeof(MEMORY_BIGBLOCKHEADERNODE)); | |
| /* Check if current big block is the first block in the list */ | |
| if (BigBlockHeader->previous != NULL) { | |
| /* if that´s not true, set previous block´s successor | |
| to current block´s successor | |
| */ | |
| BigBlockHeader->previous->next = BigBlockHeader->next; | |
| } | |
| else { | |
| /* otherwise set the first block in the big blocks list | |
| to current block´s successor | |
| */ | |
| memory_BIGBLOCKS = BigBlockHeader->next; | |
| } | |
| /* Check if current block is the last block in the list */ | |
| if (BigBlockHeader->next != NULL) { | |
| /* if that´s not true, set next block´ predecessor to | |
| current block´s predecessor | |
| */ | |
| BigBlockHeader->next->previous = BigBlockHeader->previous; | |
| } | |
| /* Adapt total number of freed bytes | |
| and number of bytes available for allocation | |
| accordingly | |
| */ | |
| memory_FREEDBYTES += RealBlockSize + memory_MARKSIZE + | |
| sizeof(MEMORY_BIGBLOCKHEADERNODE); | |
| if (memory_MAXMEM >= 0) { | |
| memory_MAXMEM += RealBlockSize + memory_MARKSIZE + | |
| sizeof(MEMORY_BIGBLOCKHEADERNODE); | |
| } | |
| /* pass the call though to free() with correct pointer value */ | |
| #ifdef CHECK | |
| free((char *)Freepointer - memory_OFFSET | |
| - sizeof(MEMORY_BIGBLOCKHEADERNODE)); | |
| #else | |
| free((char*) Freepointer - sizeof(MEMORY_BIGBLOCKHEADERNODE)); | |
| #endif | |
| } | |
| else { | |
| /* current block is not a big block */ | |
| /* Adapt number of allocated bytes | |
| and the freed blocks list accordingly | |
| */ | |
| memory_FREEDBYTES += memory_ARRAY[Size]->total_size; | |
| *(POINTER *)Freepointer = memory_ARRAY[Size]->free; | |
| memory_ARRAY[Size]->free = Freepointer; | |
| } | |
| } | |
| #endif | |
| /**************************************************************/ | |
| /* Functions */ | |
| /**************************************************************/ | |
| #ifdef __cplusplus | |
| extern "C" { | |
| #endif | |
| void memory_Init(long); | |
| void memory_Restrict(long); | |
| void memory_Print(void); | |
| void memory_FPrint(FILE*); | |
| void memory_PrintLeaks(void); | |
| void memory_PrintDetailed(void); | |
| void memory_PrintAllocatedBlocks(unsigned int Size); | |
| void memory_PrintFreedBlocks(unsigned int Size); | |
| void memory_PrintAllocatedBigBlocks(void); | |
| void memory_FreeAllMem(void); | |
| #ifdef __cplusplus | |
| } | |
| #endif | |
| #if defined(CHECK) && !defined(NO_MEMORY_MANAGEMENT) | |
| /* declare drop-in debug versions memory functions */ | |
| #ifdef __cplusplus | |
| extern "C" { | |
| #endif | |
| POINTER memory_MallocIntern(unsigned int, const char *, unsigned short int); | |
| POINTER memory_CallocIntern(unsigned int, | |
| unsigned int, | |
| const char *, | |
| unsigned short int); | |
| #ifdef __cplusplus | |
| } | |
| #endif | |
| #define memory_Malloc(Size) memory_MallocIntern((Size), __FILE__, __LINE__) | |
| #define memory_Calloc(Elements, Size) \ | |
| memory_CallocIntern((Elements), (Size), __FILE__, __LINE__) | |
| #define memory_Free(Pointer, Size) \ | |
| memory_FreeIntern((Pointer), (Size), __FILE__, __LINE__) | |
| #else | |
| #ifdef __cplusplus | |
| extern "C" { | |
| #endif | |
| POINTER memory_Malloc(unsigned int); | |
| POINTER memory_Calloc(unsigned int, unsigned int); | |
| #ifdef __cplusplus | |
| } | |
| #endif | |
| #endif | |
| #endif |