| /**************************************************************/ | |
| /* ********************************************************** */ | |
| /* * * */ | |
| /* * 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$ */ | |
| #include "memory.h" | |
| unsigned int memory_PAGESIZE; /* size of a page */ | |
| long memory_MAXMEM; /* amount of memory available for allocation */ | |
| static int memory__EOF = EOF; /* internal "End Of Memory" marker */ | |
| unsigned long memory_NEWBYTES; /* number of allocated bytes */ | |
| unsigned long memory_FREEDBYTES; /* number of freed bytes */ | |
| const unsigned int memory_ALIGN = sizeof(POINTER); | |
| /* Crucial: hardware must support access to words | |
| of size POINTER. | |
| */ | |
| #ifdef CHECK | |
| unsigned int memory_LEFTTAG; /* size of left debug mark */ | |
| unsigned int memory_OFFSET; /* alignment-correct size of left debug mark */ | |
| unsigned int memory_MARKSIZE; /* total size of debug marks */ | |
| BOOL memory_MANAGEMENT_INITIALIZED = FALSE; | |
| #else /* CHECK not defined */ | |
| unsigned int memory_MARKSIZE = 0; | |
| unsigned int memory_OFFSET = 0; | |
| #endif /* CHECK */ | |
| const unsigned int memory_MAGICMALLOC = 1; /* "block allocated" marker */ | |
| const unsigned int memory_MAGICFREE = 2; /* "block freed" marker */ | |
| /* Internal array of resources for different block sizes */ | |
| /* ... + 1 to support odd values for memory__SHAREDPAGES like 7 */ | |
| static MEMORY_RESOURCE memory_PAGES[memory__DYNMAXSIZE/memory__SHAREDPAGES + 1]; | |
| /* Resources for all administrated block sizes */ | |
| MEMORY_RESOURCE * memory_ARRAY[memory__DYNMAXSIZE]; | |
| /* double linked list for administering blocks of memory | |
| whose size is greater or equal to memory__DYNMAXSIZE. | |
| */ | |
| MEMORY_BIGBLOCKHEADER memory_BIGBLOCKS = NULL; | |
| /**************************************************************/ | |
| /* ********************************************************** */ | |
| /* * * */ | |
| /* * INITIALIZATION * */ | |
| /* * * */ | |
| /* ********************************************************** */ | |
| /**************************************************************/ | |
| #ifdef CHECK | |
| static BOOL memory_ManagementInitialized(void) | |
| /********************************************************** | |
| INPUT : None. | |
| RETURNS: TRUE if memory management is already initialized, | |
| else FALSE. | |
| SUMMARY: Checks if memory_Init was called. | |
| **********************************************************/ | |
| { | |
| return memory_MANAGEMENT_INITIALIZED; | |
| } | |
| #endif /* CHECK */ | |
| void memory_Init(long Maxmem) | |
| /************************************************************* | |
| INPUT : The maximal amount of memory available in bytes | |
| for the memory module; if Maxmem < 0 the module | |
| allocates as much memory as available from the | |
| system. | |
| RETURNS: None. | |
| SUMMARY: Initializes the memory management. It has to be | |
| called before you can perform any module operation. | |
| This function automatically increases the default | |
| page size if it is too small for two objects of | |
| size memory__DYNMAXSIZE. | |
| *************************************************************/ | |
| { | |
| int i; | |
| int extra; /* size of internally used space on each page */ | |
| memory_FREEDBYTES = 0; /* set total number of freed bytes to zero */ | |
| memory_NEWBYTES = 0; /* set total number of allocated bytes to zero */ | |
| /* set the size of a page we allocate from the operating system */ | |
| memory_PAGESIZE = memory__DEFAULTPAGESIZE; | |
| #ifdef CHECK | |
| /* Test if memory management has already been initialized */ | |
| if (!memory_ManagementInitialized()) { | |
| /* if that is not the case, set check variable to TRUE */ | |
| memory_MANAGEMENT_INITIALIZED = TRUE; | |
| } | |
| else { | |
| /* otherwise the user is trying initialize it for a | |
| second time, so print an error and exit. | |
| */ | |
| misc_StartUserErrorReport(); | |
| misc_UserErrorReport("\n In memory_Init:"); | |
| misc_UserErrorReport("\n Memory Error."); | |
| misc_UserErrorReport(" Trying to initialize memory management"); | |
| misc_UserErrorReport(" for a second time.\n"); | |
| misc_FinishUserErrorReport(); | |
| } | |
| /* Calculate the size of debug marks */ | |
| memory_LEFTTAG = sizeof(MEMORY_INFONODE) + sizeof(unsigned int); | |
| if ((sizeof(MEMORY_INFONODE) + sizeof(unsigned int)) % memory_ALIGN == 0) { | |
| memory_OFFSET = memory_LEFTTAG; | |
| } | |
| else { | |
| memory_OFFSET = memory_LEFTTAG + memory_ALIGN | |
| - (memory_LEFTTAG % memory_ALIGN); | |
| } | |
| if ((sizeof(unsigned int) % memory_ALIGN) == 0) { | |
| memory_MARKSIZE = memory_OFFSET + sizeof(unsigned int); | |
| } | |
| else { | |
| memory_MARKSIZE = memory_OFFSET + sizeof(unsigned int) + memory_ALIGN | |
| - (sizeof(unsigned int) % memory_ALIGN); | |
| } | |
| #endif | |
| /* Calculate the size of internally used space on each page */ | |
| /* extra: One pointer for chaining pages, one for EOF (+ marksize) */ | |
| extra = 2*sizeof(POINTER) + memory_MARKSIZE; | |
| /* Test whether page size is reasonable with respect | |
| to dynamic allocation threshold | |
| */ | |
| while (memory_PAGESIZE < (2*(memory__DYNMAXSIZE + memory_MARKSIZE) + extra)) { | |
| /* Minimum two objects per allocated page */ | |
| memory_PAGESIZE += memory__DEFAULTPAGESIZE/2; | |
| } | |
| /* Set amount of memory available to the module for allocation */ | |
| if (Maxmem <= 0) { | |
| /* unlimited (limited only by the operating system) */ | |
| memory_MAXMEM = memory__UNLIMITED; | |
| } | |
| else { | |
| /* Maxmem bytes */ | |
| memory_MAXMEM = Maxmem; | |
| } | |
| /* Initialize memory_ARRAY and memory_RESOURCEs */ | |
| for (i=1; i<memory__DYNMAXSIZE; i++) { | |
| MEMORY_RESOURCE *CurrentResource; | |
| int TotalSize; | |
| /* Map memory_ARRAY[i] to appropriate Resource */ | |
| memory_ARRAY[i] = &memory_PAGES[(i-1)/memory__SHAREDPAGES]; | |
| CurrentResource = memory_ARRAY[i]; | |
| CurrentResource->free = &memory__EOF; /* no blocks freed */ | |
| CurrentResource->next = &memory__EOF; /* no blocks allocated */ | |
| CurrentResource->end_of_page = &memory__EOF; /* no (end of) page */ | |
| CurrentResource->page = &memory__EOF; /* no page allocated */ | |
| /* Size of a properly aligned block of requested size i */ | |
| CurrentResource->aligned_size = memory_CalculateRealBlockSize(i); | |
| /* Total block size including debug marks */ | |
| CurrentResource->total_size = memory_MARKSIZE | |
| + CurrentResource->aligned_size; | |
| TotalSize = CurrentResource->total_size; | |
| /* last block´s offset */ | |
| CurrentResource->offset = | |
| ((memory_PAGESIZE-extra)/TotalSize)*TotalSize | |
| + sizeof(POINTER) + memory_OFFSET; | |
| } | |
| } | |
| void memory_Restrict(long Maxmem) | |
| /************************************************************* | |
| INPUT : The maximal amount of memory available for further | |
| allocation (in bytes); if Maxmem < 0 future | |
| allocations are unrestricted. | |
| RETURNS: None. | |
| SUMMARY: Sets the maximal amount of memory available for | |
| future allocations. If the user tries to allocate | |
| more memory, the module displays an error message | |
| and terminates the program by calling the exit() | |
| function. | |
| *************************************************************/ | |
| { | |
| /* Reset the maximum amount of memory available */ | |
| if (Maxmem <= 0) { | |
| /* unlimited */ | |
| memory_MAXMEM = memory__UNLIMITED; | |
| } | |
| else { | |
| /* Maxmem bytes */ | |
| memory_MAXMEM = Maxmem; | |
| } | |
| } | |
| /**************************************************************/ | |
| /* ********************************************************** */ | |
| /* * * */ | |
| /* * CHECK CODE * */ | |
| /* * * */ | |
| /* ********************************************************** */ | |
| /**************************************************************/ | |
| #ifdef CHECK | |
| static void memory_CheckIfModuleIsInitialized(const char * Function, | |
| const char * File, | |
| unsigned short int Line) | |
| /******************************************************** | |
| INPUT : The name of the function that requests the | |
| check, the name of the file and the line, | |
| where the requesting function was called, and | |
| the line. | |
| RETURNS: None. | |
| SUMMARY: Checks if the memory management module has | |
| been properly initialized. You need to | |
| initialize the module by calling memory_Init | |
| before you use any functions from the module. | |
| If the check fails, this function prints an | |
| error message and exits the application. | |
| *********************************************************/ | |
| { | |
| if (!memory_ManagementInitialized()) { | |
| misc_StartUserErrorReport(); | |
| misc_UserErrorReport("\n In %s:", Function); | |
| misc_UserErrorReport("\n Memory Error."); | |
| misc_UserErrorReport(" Memory management is not initialized."); | |
| misc_UserErrorReport("\n You have to call memory_Init()"); | |
| misc_UserErrorReport(" before you can use memory management functions.\n"); | |
| misc_UserErrorReport("\n Error occurred in %s", Function); | |
| misc_UserErrorReport(" called from file %s at line %d.\n", | |
| File, Line); | |
| misc_FinishUserErrorReport(); | |
| } | |
| } | |
| static void memory_CheckIfPointerIsAlreadyFreed(POINTER Pointer, | |
| const char * Function, | |
| const char * File, | |
| unsigned short int Line) | |
| /******************************************************** | |
| INPUT : The pointer to be checked, the name of the | |
| function that requests the check, the name of | |
| the file and the line, where the requesting | |
| function was called, and the line. | |
| RETURNS: None. | |
| SUMMARY: Checks if the pointer has already been freed. | |
| If the check fails, this function prints an | |
| error message and exits the application. | |
| *********************************************************/ | |
| { | |
| if ( memory_GetBlockStatus(Pointer) == memory_MAGICFREE) { | |
| MEMORY_INFO Info; /* block´s debug information */ | |
| Info = (MEMORY_INFO) ((char *) Pointer - memory_OFFSET); | |
| misc_StartUserErrorReport(); | |
| misc_UserErrorReport("\n In %s:", Function); | |
| misc_UserErrorReport("\n Memory Error."); | |
| misc_UserErrorReport(" Pointer %p was allocated in file %s at line %d.", | |
| Pointer, Info->mallocInFile, Info->mallocAtLine); | |
| misc_UserErrorReport("\n It has already been freed in file %s at line %d.", | |
| Info->freeInFile, Info->freeAtLine); | |
| misc_UserErrorReport("\n Size of memory block is %d bytes.", | |
| memory_GetBlockSize(Pointer)); | |
| misc_UserErrorReport("\n Error occurred in %s", Function); | |
| misc_UserErrorReport(" called from file %s at line %d.\n", | |
| File, Line); | |
| misc_FinishUserErrorReport(); | |
| } | |
| } | |
| static void memory_CheckPointer(POINTER Pointer, unsigned int Size) | |
| /********************************************************* | |
| INPUT : A pointer to a block of memory, and its size. | |
| RETURNS: Nothing. | |
| SUMMARY: Checks whether a pointer points to a valid | |
| block of memory. | |
| This function performs the following tests: | |
| Is Pointer a NULL pointer? | |
| Is Size equal to zero? | |
| Is the Pointer alignment correct? | |
| Did someone write over the memory block | |
| boundaries? | |
| Is Size still correct? | |
| If Size is greater than memory__DYNMAXSIZE: | |
| Is it properly administrated by the module? | |
| If the memory block was freed: Did someone | |
| write to it after deallocation? | |
| *********************************************************/ | |
| { | |
| MEMORY_INFO Info; | |
| unsigned int BlockSize, RealBlockSize, BlockStatus; | |
| Info = (MEMORY_INFO) ((char *) Pointer - memory_OFFSET); | |
| RealBlockSize = memory_LookupRealBlockSize(Size); | |
| if (Pointer == NULL) { | |
| /* NULL pointers must not be dereferenced */ | |
| misc_StartUserErrorReport(); | |
| misc_UserErrorReport("\n In memory_CheckPointer:"); | |
| misc_UserErrorReport("\n Memory Error. Pointer is a NULL pointer.\n"); | |
| misc_FinishUserErrorReport(); | |
| } | |
| if (Size == 0) { | |
| /* We don´t allocate 0 byte sized blocks */ | |
| misc_StartUserErrorReport(); | |
| misc_UserErrorReport("\n In memory_CheckPointer:"); | |
| misc_UserErrorReport("\n Memory Error."); | |
| misc_UserErrorReport(" Pointer %p points to a block of memory", Pointer); | |
| misc_UserErrorReport(" with size 0.\n"); | |
| misc_FinishUserErrorReport(); | |
| } | |
| if ((unsigned long)Pointer % (unsigned long)memory_ALIGN){ | |
| /* we expect all pointers to be correctly aligned */ | |
| misc_StartUserErrorReport(); | |
| misc_UserErrorReport("\n In memory_CheckPointer:"); | |
| misc_UserErrorReport("\n Memory Error."); | |
| misc_UserErrorReport(" Pointer %p is not a legal pointer.\n", Pointer); | |
| misc_FinishUserErrorReport(); | |
| } | |
| /* BlockStatus and BlockSize are initialized after | |
| we can be sure Pointer is properly aligned. | |
| */ | |
| BlockStatus = memory_GetBlockStatus(Pointer); | |
| BlockSize = memory_GetBlockSize(Pointer); | |
| if (BlockStatus != memory_MAGICMALLOC | |
| && BlockStatus != memory_MAGICFREE) { | |
| /* we expect block status to be either | |
| memory_MAGICMALLOC or memory_MAGICFREE. | |
| Other values might result from overwriting, | |
| trying to return an unallocated block, | |
| or trying to return a block allocated with | |
| another allocator. | |
| */ | |
| misc_StartUserErrorReport(); | |
| misc_UserErrorReport("\n In memory_CheckPointer:"); | |
| misc_UserErrorReport("\n Memory Error."); | |
| misc_UserErrorReport(" Pointer %p was not (de)allocated by the module,", | |
| Pointer); | |
| misc_UserErrorReport("\n or the memory block was corrupted.\n"); | |
| misc_FinishUserErrorReport(); | |
| } | |
| if (BlockStatus == memory_MAGICMALLOC) { | |
| if (BlockSize != Size) { | |
| /* we expect block size in a block´s debug | |
| information and given block size to match. | |
| */ | |
| misc_StartUserErrorReport(); | |
| misc_UserErrorReport("\n In memory_CheckPointer:"); | |
| misc_UserErrorReport("\n Memory Error."); | |
| misc_UserErrorReport(" Pointer %p was apparently allocated for", | |
| Pointer); | |
| misc_UserErrorReport(" a block of size %d,", | |
| BlockSize); | |
| misc_UserErrorReport("\n but it is expected to be a block of size %d.", | |
| Size); | |
| misc_UserErrorReport("\n Probably the memory block was corrupted.\n"); | |
| misc_FinishUserErrorReport(); | |
| /* since the left dog tag seems to be corrupted we can not safely assume | |
| that our memory info structure is still valid so we can't print it*/ | |
| } | |
| if ((Size % memory_ALIGN) || (Size % memory__SHAREDPAGES)) { | |
| /* check the fillbytes between used storage | |
| and dog tag for overwriting */ | |
| char * ptr, * limit; | |
| limit = (char *)Pointer + RealBlockSize; | |
| for (ptr = (char *)Pointer + Size; ptr < limit; ptr++) { | |
| if (*ptr != memory__FREESHREDDER) { | |
| misc_StartUserErrorReport(); | |
| misc_UserErrorReport("\n In memory_CheckPointer:"); | |
| misc_UserErrorReport("\n Memory Error."); | |
| misc_UserErrorReport(" Pointer %p was allocated in file %s at line %d,", | |
| Pointer, Info->mallocInFile, Info->mallocAtLine); | |
| misc_UserErrorReport("\n for a block of size %d.", | |
| BlockSize); | |
| misc_UserErrorReport("\n The memory block was corrupted.\n"); | |
| misc_FinishUserErrorReport(); | |
| } | |
| } | |
| } | |
| } | |
| if (Size >= memory__DYNMAXSIZE) { | |
| /* we expect big blocks to be correctly linked */ | |
| MEMORY_BIGBLOCKHEADER BigBlockHeader; | |
| BigBlockHeader = (MEMORY_BIGBLOCKHEADER) ((char *) Pointer - memory_OFFSET | |
| - sizeof(MEMORY_BIGBLOCKHEADERNODE)); | |
| /* this test might crash the program | |
| if something is wrong with the pointers, | |
| so you may not get a message every time. | |
| */ | |
| if (((BigBlockHeader->previous != NULL) | |
| && (BigBlockHeader->previous->next != BigBlockHeader)) | |
| || ((BigBlockHeader->previous == NULL) | |
| && (memory_BIGBLOCKS != BigBlockHeader)) | |
| || ((BigBlockHeader->next != NULL) | |
| && (BigBlockHeader->next->previous != BigBlockHeader))) { | |
| misc_StartUserErrorReport(); | |
| misc_UserErrorReport("\n In memory_CheckPointer:"); | |
| misc_UserErrorReport("\n Memory Error."); | |
| misc_UserErrorReport(" Pointer %p was not allocated by the module,", | |
| Pointer); | |
| misc_UserErrorReport("\n or the memory block was corrupted.\n"); | |
| misc_FinishUserErrorReport(); | |
| } | |
| } | |
| if (BlockStatus == memory_MAGICFREE) { | |
| /* test if someone wrote over freed memory */ | |
| char * ptr, * limit; | |
| limit = (char *)Pointer + RealBlockSize; | |
| for (ptr = (char *)Pointer + sizeof(POINTER); ptr < limit ; ptr++){ | |
| /* first sizeof(POINTER) bytes are reserved for the | |
| pointer to the next freed block in the list. All | |
| other bytes in the block should still have the value | |
| of memory__FREESHREDDER | |
| */ | |
| if (*ptr != memory__FREESHREDDER) { | |
| misc_StartUserErrorReport(); | |
| misc_UserErrorReport("\n In memory_CheckPointer:"); | |
| misc_UserErrorReport("\n Memory Error."); | |
| misc_UserErrorReport(" Pointer %p was allocated in file %s at line %d", | |
| Pointer, Info->mallocInFile, Info->mallocAtLine); | |
| misc_UserErrorReport("\n for a block of size %d",BlockSize); | |
| misc_UserErrorReport("\n and freed in file %s at line %d.", | |
| Info->freeInFile, Info->freeAtLine); | |
| misc_UserErrorReport("\n The memory block was used after deallocation.\n"); | |
| misc_FinishUserErrorReport(); | |
| } | |
| } | |
| } | |
| } | |
| void memory_CheckFree(POINTER Freepointer, unsigned int Size, | |
| unsigned int RealBlockSize, const char * File, | |
| unsigned short int Line) | |
| /********************************************************** | |
| INPUT : The pointer to be freed, the size of the block | |
| it is supposed to point to, the real size of | |
| that block, the file and line where memory_Free | |
| was called. | |
| RETURNS: None. | |
| SUMMARY: Checks if memory management was initialized, | |
| the given pointer is legal, and not freed | |
| already. It also zeroes the freed memory, and | |
| sets the block's debug and administration | |
| information. | |
| **********************************************************/ | |
| { | |
| MEMORY_INFO Info; /* block´s debug information */ | |
| /* Check if memory management was initialized */ | |
| memory_CheckIfModuleIsInitialized("memory_Free", File, Line); | |
| /* Check if given pointer is legal */ | |
| memory_CheckPointer(Freepointer, Size); | |
| /* Check if current pointer is being freed for a second time */ | |
| memory_CheckIfPointerIsAlreadyFreed(Freepointer, "memory_Free", File, Line); | |
| /* Set all bytes to zero, so we can detect overwriting of freed memory */ | |
| memset (Freepointer, memory__FREESHREDDER, RealBlockSize); | |
| /* Get current block´s debug information */ | |
| Info = (MEMORY_INFO) ((char *) Freepointer - memory_OFFSET); | |
| /* Set block´s debug and administration information */ | |
| memory_SetInfo(Info,Info->mallocInFile, Info->mallocAtLine, File, Line); | |
| memory_SetBlockStatusAndSize(Freepointer, memory_MAGICFREE, Size); | |
| } | |
| #endif /* CHECK */ | |
| /**************************************************************/ | |
| /* ********************************************************** */ | |
| /* * * */ | |
| /* * MALLOC * */ | |
| /* * * */ | |
| /* ********************************************************** */ | |
| /**************************************************************/ | |
| #ifdef NO_MEMORY_MANAGEMENT | |
| POINTER memory_Malloc(unsigned int Bytes) | |
| { | |
| char *mem; /* pointer to memory block obtained from malloc */ | |
| /* Pass the call through to compiler´s malloc */ | |
| mem = (char *)malloc(Bytes); | |
| /* If malloc fails print an error message and exit */ | |
| if (mem == NULL) { | |
| misc_StartUserErrorReport(); | |
| misc_UserErrorReport("\n In memory_Malloc:"); | |
| misc_UserErrorReport("\n Memory Error. Out of memory.\n"); | |
| misc_FinishUserErrorReport(); | |
| } | |
| return mem; | |
| } | |
| #else | |
| #ifdef CHECK | |
| POINTER memory_MallocIntern(unsigned int Bytes, | |
| const char * File, | |
| unsigned short int Line) | |
| #else | |
| POINTER memory_Malloc(unsigned int Bytes) | |
| #endif | |
| /******************************************************** | |
| INPUT : The size of the requested memory block. | |
| RETURNS: A pointer to a block of <Bytes> bytes. | |
| SUMMARY: Allocates a memory block of requested length. | |
| EXCEPT : Trying to allocate 0 bytes, violating a memory | |
| restriction, or running out of system memory | |
| cause the function to print an error message and | |
| call exit(). | |
| *********************************************************/ | |
| { | |
| char *NewMemory; /* pointer to allocated memory */ | |
| MEMORY_RESOURCE *Resource; /* current page resource, | |
| required if we do not allocate | |
| a big block */ | |
| #ifdef CHECK | |
| MEMORY_INFO NewInfo; /* Storage for file and line | |
| of allocation */ | |
| #endif | |
| #ifdef CHECK | |
| /* Is the module initialized? */ | |
| memory_CheckIfModuleIsInitialized("memory_Malloc", File, Line); | |
| /* Is it a request for a block of zero bytes? */ | |
| if (Bytes == 0) { | |
| /* The latest draft for the ANSI C 9X standard says in section 7.20.3: | |
| "If the size of the space requested is zero, the behavior is | |
| implementation-defined: either a null pointer is returned, or | |
| the behavior is as if the size were some nonzero value, | |
| except that the pointer shall not be used to access an object." | |
| We have decided to print an error and exit upon such requests | |
| since they are often originated by a bug. | |
| Nonstandard but hopefully helpful. | |
| */ | |
| misc_StartUserErrorReport(); | |
| misc_UserErrorReport("\n In memory_Malloc:"); | |
| misc_UserErrorReport("\n Memory Error. Tried to allocate 0 Bytes!"); | |
| misc_UserErrorReport("\n Error occurred in memory_Malloc"); | |
| misc_UserErrorReport(" called from file %s at line %d.\n", | |
| File, Line); | |
| misc_FinishUserErrorReport(); | |
| } | |
| #endif | |
| /* If it is a big block, then it has to be | |
| administrated in a special way | |
| */ | |
| if (Bytes >= memory__DYNMAXSIZE) { | |
| unsigned int RealBigBlockSize; /* real block size including | |
| padding,header | |
| and debug marks */ | |
| /* This is what a big block looks like: | |
| -------------------------------------------------------------------- | |
| | MEMORY_BIGBLOCKHEADERNODE | debug marks | char * | debug marks | | |
| | previous and next big block |in debug mode| block |in debug mode| | |
| -------------------------------------------------------------------- | |
| */ | |
| /* Calculate the real size of the big block, | |
| from the size of administration information, | |
| the size of debug marks and the requested block size | |
| */ | |
| RealBigBlockSize = sizeof(MEMORY_BIGBLOCKHEADERNODE) + | |
| memory_MARKSIZE + memory_CalculateRealBlockSize(Bytes); | |
| /* Check for violation of maximum allocation limit */ | |
| if (memory_MAXMEM >= 0) { | |
| /* there is a maximum allocation limit, | |
| let´s see if there is enough left | |
| */ | |
| if ((unsigned int)memory_MAXMEM < RealBigBlockSize) { | |
| /* if it is not print an error message and exit */ | |
| misc_StartUserErrorReport(); | |
| misc_UserErrorReport("\n In memory_Malloc:"); | |
| misc_UserErrorReport("\n Memory Error."); | |
| misc_UserErrorReport(" Terminated by user given memory restriction,\n"); | |
| misc_UserErrorReport("\n while trying to allocate %lu bytes.\n", | |
| RealBigBlockSize); | |
| misc_UserErrorReport("\n Maximum amount of memory"); | |
| misc_UserErrorReport(" left for allocation is %l bytes.\n", | |
| memory_MAXMEM); | |
| #ifdef CHECK | |
| misc_UserErrorReport("\n Error occurred in memory_Malloc"); | |
| misc_UserErrorReport(" called from file %s at line %d.\n", | |
| File, Line); | |
| #endif | |
| misc_FinishUserErrorReport(); | |
| } | |
| else | |
| /* otherwise subtract the real block size | |
| from the amount of memory available for | |
| allocation | |
| */ | |
| memory_MAXMEM -= RealBigBlockSize; | |
| } | |
| /* allocate a fresh block of memory via a call to malloc */ | |
| NewMemory = (char *)malloc(RealBigBlockSize); | |
| /* Check if allocation was successful */ | |
| if (NewMemory != NULL) { | |
| /* if it was, then administrate the fresh block: | |
| insert it into the big block list. The list | |
| is double linked for fast deletion | |
| */ | |
| MEMORY_BIGBLOCKHEADER NewBigBlock; /* new block´s administration | |
| information */ | |
| /* insert the fresh block as the first list element */ | |
| NewBigBlock = (MEMORY_BIGBLOCKHEADER) NewMemory; | |
| NewBigBlock->next = memory_BIGBLOCKS; | |
| NewBigBlock->previous = NULL; | |
| /* if there are already elements in the big block list, | |
| change the first element´s pointer to the previous block | |
| to point to the fresh block´s administration information | |
| */ | |
| if (memory_BIGBLOCKS != NULL) { | |
| memory_BIGBLOCKS->previous = NewBigBlock; | |
| } | |
| /* reset the big block list pointer to point to the fresh block */ | |
| memory_BIGBLOCKS = NewBigBlock; | |
| /* skip the administration information */ | |
| NewMemory += sizeof(MEMORY_BIGBLOCKHEADERNODE); | |
| #ifdef CHECK | |
| /* set the debug information address */ | |
| NewInfo = (MEMORY_INFO) NewMemory; | |
| /* skip left debug mark */ | |
| NewMemory += memory_OFFSET; | |
| #endif | |
| /* add block´s real size to the total sum of allocated bytes */ | |
| memory_NEWBYTES += RealBigBlockSize; | |
| } | |
| else { | |
| /* NewMemory == NULL. | |
| malloc could not allocate a memory block of required size, | |
| so we print an error message and exit | |
| */ | |
| misc_StartUserErrorReport(); | |
| misc_UserErrorReport("\n In memory_MallocIntern:"); | |
| misc_UserErrorReport("\n Memory Error. Out of memory."); | |
| misc_UserErrorReport("\n Failed to allocate %d bytes.\n", | |
| RealBigBlockSize); | |
| #ifdef CHECK | |
| misc_UserErrorReport("\n Error occurred in memory_Malloc"); | |
| misc_UserErrorReport(" called from file %s at line %d.\n", | |
| File, Line); | |
| #endif | |
| misc_FinishUserErrorReport(); | |
| } | |
| } | |
| else { | |
| /* Bytes < memory__DYNMAXSIZE. | |
| A memory request for a manageable size | |
| */ | |
| /* Initialize the memory resource for the given size */ | |
| Resource = memory_ARRAY[Bytes]; | |
| /* Check if there are freed blocks of that size */ | |
| if (*((int *)Resource->free) != EOF) { | |
| /* if that is the case, then use an already freed block */ | |
| NewMemory = (char *) Resource->free; | |
| /* update the free blocks list for that size */ | |
| Resource->free = *((POINTER *)(NewMemory)); | |
| /* subtract block´s total size from the sum of freed bytes */ | |
| memory_FREEDBYTES -= Resource->total_size; | |
| #ifdef CHECK | |
| /* calculate the address of the block´s debug information */ | |
| NewInfo = (MEMORY_INFO) ((char*) NewMemory - memory_OFFSET); | |
| /* Check if the block has been used after deallocation */ | |
| memory_CheckPointer(NewMemory, Bytes); | |
| #endif | |
| } | |
| else { | |
| /* there are no already freed blocks of that size */ | |
| /* Check if there is enough space left on current page */ | |
| if (Resource->next != Resource->end_of_page) { | |
| /* if that is the case, then use a fresh block from current page */ | |
| NewMemory = (char *)Resource->next; | |
| /* update the pointer to the next usable block */ | |
| Resource->next = NewMemory + Resource->total_size; | |
| /* add block´s total size to the sum of allocated bytes */ | |
| memory_NEWBYTES += Resource->total_size; | |
| #ifdef CHECK | |
| /* Check if the fresh block´s address is sane */ | |
| if ((char *)NewMemory > (char *) Resource->end_of_page) { | |
| /* if it is not, then we have detected an internal error | |
| in the module itself. Oops! So we print an error message | |
| and abort, hoping that the core dump will enable us to | |
| trace the error back to its origin | |
| */ | |
| misc_StartErrorReport(); | |
| misc_ErrorReport("\n In memory_Malloc:"); | |
| misc_ErrorReport("\n Memory Error. Address overflow %d.",Bytes); | |
| misc_ErrorReport("\n Error occurred in memory_Malloc"); | |
| misc_ErrorReport(" called from file %s at line %d.\n", File, Line); | |
| misc_FinishErrorReport(); | |
| } | |
| /* if all is well, we initialize the pointer to fresh block´s | |
| debug information | |
| */ | |
| NewInfo = (MEMORY_INFO)((char*) NewMemory - memory_OFFSET); | |
| #endif | |
| } | |
| else { | |
| /* Check for violation of maximum allocation limit */ | |
| if (memory_MAXMEM >=0) { | |
| /* there is a maximum allocation limit, | |
| let´s see if there is enough left | |
| */ | |
| if ((unsigned int)memory_MAXMEM < memory_PAGESIZE) { | |
| /* if it is not, then print an error message and exit */ | |
| misc_StartUserErrorReport(); | |
| misc_UserErrorReport("\n In memory_Malloc:"); | |
| misc_UserErrorReport("\n Memory Error."); | |
| misc_UserErrorReport(" Terminated by user given memory restriction.\n"); | |
| #ifdef CHECK | |
| misc_UserErrorReport("\n Error occurred in memory_Malloc"); | |
| misc_UserErrorReport(" called from file %s at line %d.\n", | |
| File, Line); | |
| #endif | |
| misc_FinishUserErrorReport(); | |
| } | |
| else { | |
| /* otherwise subtract the page size from the limit */ | |
| memory_MAXMEM -= memory_PAGESIZE; | |
| } | |
| } | |
| /* try to allocate a new page via malloc */ | |
| NewMemory=(char *)malloc(memory_PAGESIZE); | |
| /* check if allocation was successful */ | |
| if (NewMemory == NULL) { | |
| /* if it wasn´t print an error message and exit */ | |
| misc_StartUserErrorReport(); | |
| misc_UserErrorReport("\n In memory_Malloc:"); | |
| misc_UserErrorReport("\n Memory Error."); | |
| misc_UserErrorReport(" Terminated, ran out of system memory.\n"); | |
| #ifdef CHECK | |
| misc_UserErrorReport("\n Error occurred in memory_Malloc"); | |
| misc_UserErrorReport(" called from file %s at line %d.\n", | |
| File, Line); | |
| #endif | |
| misc_FinishUserErrorReport(); | |
| } | |
| /* otherwise administrate the fresh page, | |
| i.e insert it as the first element of the | |
| page list for the given size | |
| */ | |
| *((POINTER *)NewMemory) = Resource->page; | |
| Resource->page = NewMemory; | |
| /* add block´s total size to the sum of allocated bytes */ | |
| memory_NEWBYTES += Resource->total_size; | |
| /* set the end of page pointer for the fresh page */ | |
| Resource->end_of_page = (char *) NewMemory + Resource->offset; | |
| /* skip the page list */ | |
| NewMemory += sizeof(POINTER); | |
| #ifdef CHECK | |
| /* set the debug information address */ | |
| NewInfo = (MEMORY_INFO) NewMemory; | |
| /* skip the left debug mark */ | |
| NewMemory += memory_OFFSET; | |
| #endif | |
| /* update the pointer to the next usable block */ | |
| Resource->next = NewMemory + Resource->total_size; | |
| } | |
| } | |
| } | |
| #ifdef CHECK | |
| /* Set block´s debug information */ | |
| memory_SetInfo(NewInfo, File, Line, NULL, 0); | |
| memory_SetBlockStatusAndSize(NewMemory, | |
| memory_MAGICMALLOC, Bytes); | |
| /* delete all block´s usable bytes with a shredder value */ | |
| memset(NewMemory, memory__FREESHREDDER, | |
| memory_LookupRealBlockSize(Bytes)); | |
| #endif | |
| return NewMemory; | |
| } | |
| #endif | |
| #ifdef NO_MEMORY_MANAGEMENT | |
| POINTER memory_Calloc(unsigned int Elements, unsigned int Bytes) | |
| { | |
| char *mem; /* pointer to memory block obtained from calloc */ | |
| /* Pass call through to compiler´s calloc */ | |
| mem = (char *)calloc(Elements, Bytes); | |
| /* If calloc fails print an error message and exit */ | |
| if (mem == NULL) { | |
| misc_StartUserErrorReport(); | |
| misc_UserErrorReport("\n In memory_Calloc:"); | |
| misc_UserErrorReport("\n Memory Error. Out of memory.\n"); | |
| misc_FinishUserErrorReport(); | |
| } | |
| return mem; | |
| } | |
| #else | |
| #ifdef CHECK | |
| POINTER memory_CallocIntern(unsigned int Elements, unsigned int Bytes, | |
| const char * File, unsigned short int Line) | |
| #else | |
| POINTER memory_Calloc(unsigned int Elements, unsigned int Bytes) | |
| #endif | |
| /******************************************************** | |
| INPUT : The number of requested equally huge blocks, | |
| and each block's size. | |
| RETURNS: A pointer to a block of (Bytes * Elements) bytes. | |
| SUMMARY: Allocates a memory block of requested length | |
| filled with char value '\0'. | |
| *********************************************************/ | |
| { | |
| char * mem; /* pointer to memory block obtained from the module */ | |
| /* Allocate memory via our memory management */ | |
| #ifdef CHECK | |
| mem = (char *)memory_MallocIntern(Elements * Bytes, File, Line); | |
| #else | |
| mem = (char *)memory_Malloc(Elements * Bytes); | |
| #endif | |
| /* If allocation was successful set all bytes to zero */ | |
| if (mem != NULL) { | |
| memset(mem,0, Elements * Bytes); | |
| } | |
| /* otherwise print an error message and exit */ | |
| else { | |
| misc_StartUserErrorReport(); | |
| misc_UserErrorReport("\n In memory_Calloc:"); | |
| misc_UserErrorReport("\n Memory Error. Out of memory.\n"); | |
| #ifdef CHECK | |
| misc_UserErrorReport("\n Error occurred in memory_Calloc"); | |
| misc_UserErrorReport(" called from file %s at line %d.\n", | |
| File, Line); | |
| #endif | |
| misc_FinishUserErrorReport(); | |
| } | |
| return mem; | |
| } | |
| #endif | |
| void memory_FreeAllMem(void) | |
| /************************************************************** | |
| INPUT : None. | |
| RETURNS: None. | |
| SUMMARY: Frees all memory allocated by calls to the module. | |
| ***************************************************************/ | |
| { | |
| int i; | |
| /* delete all pages first by going through the memory_ARRAY. | |
| This is slower than traversing the array memory_PAGES | |
| directly, but is easier to implement correctly. Since | |
| the only reasonable way to call memory_FreeAllMem is | |
| before the program exits, a minimal performance penalty | |
| should be acceptable | |
| */ | |
| for (i = 1; i < memory__DYNMAXSIZE; i++) { | |
| POINTER thispage, nextpage; | |
| MEMORY_RESOURCE * Resource; | |
| Resource = memory_ARRAY[i]; | |
| thispage = Resource->page; | |
| if (*((int *)thispage) != EOF) { | |
| do { | |
| nextpage = *((POINTER *)thispage); | |
| free(thispage); | |
| thispage = nextpage; | |
| } while (*((int *)thispage) != EOF); | |
| /* and reset the resource structure */ | |
| Resource->page = &memory__EOF; | |
| Resource->free = &memory__EOF; | |
| Resource->next = &memory__EOF; | |
| Resource->end_of_page = &memory__EOF; | |
| } | |
| } | |
| /* now delete all big blocks left */ | |
| if (memory_BIGBLOCKS != NULL) { | |
| MEMORY_BIGBLOCKHEADER thisblock, nextblock; | |
| for (thisblock = memory_BIGBLOCKS; | |
| thisblock != NULL; | |
| thisblock = nextblock) { | |
| nextblock = thisblock->next; | |
| free(thisblock); | |
| } | |
| /* and reset the list pointer */ | |
| memory_BIGBLOCKS = NULL; | |
| } | |
| } | |
| /**************************************************************/ | |
| /* ********************************************************** */ | |
| /* * * */ | |
| /* * DEBUGGING INFORMATION * */ | |
| /* * * */ | |
| /* ********************************************************** */ | |
| /**************************************************************/ | |
| void memory_Print(void) | |
| /************************************************************** | |
| INPUT : None. | |
| RETURNS: None. | |
| SUMMARY: Prints module status information to stdout: | |
| the fixed size of an internal memory page, the size | |
| of debug marks for a block of memory, the size of | |
| demanded and freed memory in kilobytes, remaining | |
| memory in bytes and the number of allocated pages of | |
| memory. | |
| ***************************************************************/ | |
| { | |
| #ifndef NO_MEMORY_MANAGEMENT | |
| /* Call memory_FPrint to print status information to stdout */ | |
| memory_FPrint(stdout); | |
| #endif | |
| } | |
| void memory_FPrint(FILE* File) | |
| /************************************************************** | |
| INPUT : A file pointer. | |
| RETURNS: None. | |
| SUMMARY: Prints module status information to given File: | |
| the fixed size of an internal memory page, the size | |
| of debug marks for a block of memory, the size of | |
| demanded and freed memory in kilobytes, remaining | |
| memory in bytes and the number of allocated pages of | |
| memory. | |
| ***************************************************************/ | |
| { | |
| #ifndef NO_MEMORY_MANAGEMENT | |
| int Pages; /* number of allocated pages */ | |
| int i; | |
| POINTER ActPage; /* current page in page list for a block size */ | |
| /* Calculate the total number of pages */ | |
| Pages = 0; | |
| for (i = 1; i < memory__DYNMAXSIZE; i+=memory__SHAREDPAGES) { | |
| /* increase i by memory_SHAREDPAGES due to page sharing */ | |
| ActPage = memory_ARRAY[i]->page; | |
| /* Traverse the page list */ | |
| while (*((int *)ActPage) != EOF) { | |
| Pages++; | |
| ActPage = *((POINTER *)ActPage); | |
| } | |
| } | |
| /* Print status information */ | |
| fputs("\n###\n", File); | |
| fprintf(File,"### Pagesize: %d\n", | |
| memory_PAGESIZE); | |
| fprintf(File,"### Marksize: %d\n", | |
| (int)memory_MARKSIZE); | |
| fprintf(File,"### Memory demanded: %lu KBytes\n", | |
| memory_NEWBYTES/memory__KILOBYTE); | |
| fprintf(File,"### Memory freed: %lu KBytes\n", | |
| memory_FREEDBYTES/memory__KILOBYTE); | |
| fprintf(File,"### Memory remaining: %lu Bytes\n", | |
| memory_NEWBYTES-memory_FREEDBYTES); | |
| fprintf(File,"### Pages allocated: %d Pages\n", | |
| Pages); | |
| fputs("###\n", File); | |
| #endif | |
| } | |
| void memory_PrintAllocatedBlocks(unsigned int Size) | |
| /************************************************************** | |
| INPUT : Block size. | |
| RETURNS: None. | |
| SUMMARY: Prints addresses of allocated memory blocks with | |
| given Size to stdout, if Size is less than | |
| memory_DYNMAXSIZE. | |
| ***************************************************************/ | |
| { | |
| #ifndef NO_MEMORY_MANAGEMENT | |
| MEMORY_RESOURCE *Resource; /* current resource */ | |
| POINTER ActPage; /* current page */ | |
| POINTER ActNext; /* next usable block on current page */ | |
| POINTER ActEndOfPage; /* end of current page */ | |
| unsigned int BlockSize; /* current block size */ | |
| #ifdef CHECK | |
| MEMORY_INFO Info; /* current block´s debug information */ | |
| #endif | |
| /* Allocated blocks are administered | |
| in two ways depending on their | |
| size. If the size is less than | |
| memory__DYNMAXSIZE the block is | |
| allocated from the appropriate | |
| page. Otherwise the block is | |
| allocated directly via a call | |
| to malloc or calloc. | |
| Thus we have two functions to | |
| print the allocated blocks: | |
| memory_PrintAllocatedBlocks and | |
| memory_PrintAlocatedBigBlocks. | |
| */ | |
| /* Check if memory_PrintAllocatedBlocks has been called for | |
| a legal block size | |
| */ | |
| if (Size >= memory__DYNMAXSIZE) { | |
| /* if that´s not the case print an error message and exit */ | |
| misc_StartUserErrorReport(); | |
| misc_UserErrorReport("\n In memory_PrintAllocatedBlocks:"); | |
| misc_UserErrorReport("\n Parameter size is too big: %d.", | |
| Size); | |
| misc_UserErrorReport("\n Maximal allowed value is: %d.\n", | |
| memory__DYNMAXSIZE); | |
| misc_FinishUserErrorReport(); | |
| } | |
| else { | |
| /* otherwise size is legal */ | |
| /* initialize the variables */ | |
| Resource = memory_ARRAY[Size]; | |
| ActPage = Resource->page; | |
| ActNext = Resource->next; | |
| ActEndOfPage = Resource->end_of_page; | |
| BlockSize = Resource->total_size; | |
| /* Test if there were any requests made for blocks of that size */ | |
| if (*((int *)ActPage) == EOF) { | |
| /* Check if pointers are consistent */ | |
| if (*((int *)ActNext) == EOF) { | |
| /* If that is true, print that information to stdout */ | |
| puts(" No request so far"); | |
| } | |
| else { | |
| /* Otherwise print an error message and abort */ | |
| misc_StartErrorReport(); | |
| misc_ErrorReport("\n In memory_PrintAllocatedBlocks:"); | |
| misc_ErrorReport("\n Memory Error. No Page entry but Next entry.\n"); | |
| misc_FinishErrorReport(); | |
| } | |
| } | |
| else { | |
| /* We have received some requests for blocks of that size */ | |
| #ifdef CHECK | |
| POINTER ActData; /* current block */ | |
| /* Traverse through the page list for given block size */ | |
| while (*((int *)ActPage) != EOF) { | |
| /* Initialize the variables */ | |
| ActData = (char *)ActPage + sizeof(POINTER) + memory_OFFSET; | |
| ActEndOfPage = (char *)ActPage + Resource->offset; | |
| /* Visit blocks on current page until the end of | |
| page is reached, or an allocated block is found | |
| */ | |
| while (ActData != ActNext | |
| && ActData != ActEndOfPage | |
| && memory_GetBlockStatus(ActData) != memory_MAGICMALLOC) { | |
| ActData = (char *)ActData + BlockSize; | |
| } | |
| /* Check if there were any allocated blocks from current page */ | |
| if (ActData == ActNext || ActData == ActEndOfPage) { | |
| /* if that´s not the case print the information to stdout */ | |
| printf("\n\n No memory allocated from page at address %p\n", ActPage); | |
| } | |
| else { | |
| /* otherwise print address and origin of (de)allocation of | |
| all allocated blocks on current page, starting | |
| with the block just found | |
| */ | |
| fputs("\n\n Allocated but not freed: ", stdout); | |
| do { | |
| Info = (MEMORY_INFO) ((char *) ActData - memory_OFFSET); | |
| if (memory_GetBlockStatus(ActData) == memory_MAGICMALLOC | |
| && memory_GetBlockSize(ActData) == Size) { | |
| printf("\n\t%p allocated in file %s at line %d ", | |
| ActData, Info->mallocInFile, Info->mallocAtLine); | |
| } | |
| ActData = (char *)ActData + BlockSize; | |
| } while (ActData != ActNext && ActData != ActEndOfPage); | |
| } | |
| /* go to the next page in the page list for given block size */ | |
| ActPage = *((POINTER *)ActPage); | |
| } | |
| #endif | |
| } | |
| } | |
| #endif | |
| } | |
| void memory_PrintFreedBlocks(unsigned int Size) | |
| /************************************************************** | |
| INPUT : Block size. | |
| RETURNS: None. | |
| SUMMARY: Prints addresses of freed memory blocks with given | |
| Size to stdout, if Size is less than | |
| memory_DYNMAXSIZE. | |
| ***************************************************************/ | |
| { | |
| #ifndef NO_MEMORY_MANAGEMENT | |
| POINTER ActFree; /* current block */ | |
| #ifdef CHECK | |
| MEMORY_INFO Info; /* current block´s debug information */ | |
| #endif | |
| /* since we don´t recycle blocks whose size is | |
| greater or equal to memory__DYNMAXSIZE, | |
| memory_PrintFreedBlocks is meaningless | |
| for such block sizes. | |
| */ | |
| /* test if given block size is legal */ | |
| if (Size >= memory__DYNMAXSIZE) { | |
| /* if that´s not the case print an error message and exit */ | |
| misc_StartUserErrorReport(); | |
| misc_UserErrorReport("\n In memory_PrintFreedBlocks."); | |
| misc_UserErrorReport("\n Parameter Size is too big: %d.", | |
| Size); | |
| misc_UserErrorReport("\n Maximal allowed value is: %d.\n", | |
| memory__DYNMAXSIZE); | |
| misc_FinishUserErrorReport(); | |
| } | |
| else { | |
| /* otherwise size is legal */ | |
| /* start at the first element of the free block list | |
| for the given block size | |
| */ | |
| ActFree = memory_ARRAY[Size]->free; | |
| /* test if the free block list is empty */ | |
| if (*((int *)ActFree) == EOF) { | |
| /* if that´s true, print that information to stdout */ | |
| puts("\n\n No freed memory"); | |
| } | |
| else { | |
| /* otherwise traverse the list of freed blocks */ | |
| fputs("\n\n Free: ", stdout); | |
| while (*((int *)ActFree) != EOF) { | |
| #ifdef CHECK | |
| /* in debug mode print current block´s address | |
| and origin of (de)allocation | |
| */ | |
| /* check if block´s size is correct */ | |
| if ( memory_GetBlockSize(ActFree) == Size) { | |
| /* if that´s true than print block´s information */ | |
| Info = (MEMORY_INFO) ((char *) ActFree - memory_OFFSET); | |
| printf("\n\t%p\tallocated in file %s at line %d", | |
| ActFree, Info->mallocInFile, Info->mallocAtLine); | |
| printf("\n\t\tfreed in file %s at line %d", | |
| Info->freeInFile, Info->freeAtLine); | |
| } | |
| else { | |
| /* otherwise if we are sharing pages among different | |
| block sizes, the block is uncorrupted, despite not | |
| matching assumed and real size. But if we are | |
| not sharing pages then the block is probably corrupted, | |
| so print an error message and exit | |
| */ | |
| /* test if we are not in page sharing mode */ | |
| if (memory__SHAREDPAGES == 1) { | |
| /* if that´s true print an error message and exit */ | |
| misc_StartUserErrorReport(); | |
| misc_UserErrorReport("\n In memory_PrintFreedBlocks:"); | |
| misc_UserErrorReport("\n Memory Error. Memory block size mismatch."); | |
| misc_UserErrorReport("\n Expected %d found %d for memory block at %p.\n", | |
| Size, memory_GetBlockSize(ActFree), ActFree); | |
| misc_UserErrorReport("\n Probably the memory block was corrupted.\n"); | |
| misc_FinishUserErrorReport(); | |
| } | |
| } | |
| #endif | |
| /* go to the next free block in list */ | |
| ActFree = *((POINTER *)ActFree); | |
| } | |
| } | |
| } | |
| #endif | |
| } | |
| void memory_PrintAllocatedBigBlocks(void) | |
| /************************************************************** | |
| INPUT : None. | |
| RETURNS: None. | |
| SUMMARY: Prints addresses of all allocated memory blocks, | |
| that are greater than memory_DYNMAXSIZE to stdout. | |
| ***************************************************************/ | |
| { | |
| #ifndef NO_MEMORY_MANAGEMENT | |
| #ifdef CHECK | |
| MEMORY_BIGBLOCKHEADER Ptr; /* current big block in list */ | |
| MEMORY_INFO Info; /* block´s debug information */ | |
| char * BlockStart; /* block´s start address */ | |
| /* start with the first block in the big block list */ | |
| Ptr = memory_BIGBLOCKS; | |
| /* check whether big block list isn´t empty */ | |
| if (Ptr != NULL) { | |
| /* if that´s the case traverse through the list | |
| and print each block´s address, size and | |
| origin of (de)allocation information | |
| */ | |
| do { | |
| BlockStart = (char *)Ptr + memory_OFFSET | |
| + sizeof(MEMORY_BIGBLOCKHEADERNODE); | |
| Info = (MEMORY_INFO) (BlockStart - memory_OFFSET); | |
| printf("\n\t%p %d bytes allocated in file %s at line %d ", | |
| (void*)BlockStart, memory_GetBlockSize(BlockStart), | |
| Info->mallocInFile, Info->mallocAtLine); | |
| Ptr = Ptr->next; | |
| } while (Ptr != NULL); | |
| puts(""); | |
| } | |
| else { | |
| /* otherwise there are no big blocks allocated */ | |
| puts(" No request so far"); | |
| } | |
| #endif | |
| #endif | |
| } | |
| void memory_PrintDetailed(void) | |
| /************************************************************** | |
| INPUT : None. | |
| RETURNS: None. | |
| SUMMARY: Prints addresses of all pages, and allocated and freed | |
| blocks on them. | |
| ***************************************************************/ | |
| { | |
| #ifndef NO_MEMORY_MANAGEMENT | |
| MEMORY_RESOURCE *Resource; /* current resource */ | |
| POINTER ActPage; /* current page */ | |
| POINTER ActData; /* current block */ | |
| POINTER ActEndOfPage; /* end of current page */ | |
| unsigned int BlockSize; /* total size of a block of current size */ | |
| unsigned int PageOffset; /* current page´s offset */ | |
| unsigned int i; | |
| /* print end-of-memory pointer´s address */ | |
| printf("\n\nEOF Pointer: %p\n", (void*)&memory__EOF); | |
| /* for all administrated block sizes print detailed information */ | |
| for (i=1; i<memory__DYNMAXSIZE; i++) { | |
| /* initialize variables for requested block size i */ | |
| Resource = memory_ARRAY[i]; | |
| ActPage = Resource->page; | |
| ActData = Resource->next; | |
| ActEndOfPage = Resource->end_of_page; | |
| PageOffset = Resource->offset; | |
| BlockSize = Resource->total_size; | |
| /* print requested block size, aligned block size | |
| and block size including debug marks | |
| */ | |
| printf("\n\n Entry: %d aligned size: %d total size: %d\n", | |
| i , Resource->aligned_size, BlockSize); | |
| /* Check if there were any requests for blocks of size i */ | |
| if (*((int *)ActPage) == EOF) { | |
| /* if that´s not the case check if memory management is consistent */ | |
| if (*((int *)ActData) == EOF) { | |
| /* if that´s true, print that no requests occurred to stdout */ | |
| puts(" No request so far"); | |
| } | |
| else { | |
| /* our memory management is no longer consistent, | |
| so print an error message and abort. We hope that | |
| the core dump will help us to find the bug | |
| */ | |
| misc_StartErrorReport(); | |
| misc_ErrorReport("\n In memory_PrintDetailed:"); | |
| misc_ErrorReport("\n Memory Error. No Page entry but Next entry.\n"); | |
| misc_FinishErrorReport(); | |
| } | |
| } | |
| else { | |
| /* we have received requests for blocks of size i */ | |
| /* traverse the list of pages for size i */ | |
| while (*((int *)ActPage) != EOF) { | |
| /* print information about current page */ | |
| printf("\n\n Page: %p Next Page: %p\n", | |
| ActPage, *((POINTER *)ActPage)); | |
| /* initialize variables for current page */ | |
| ActData = ((char *)ActPage + sizeof(POINTER) + memory_OFFSET); | |
| ActEndOfPage = (char *)ActPage + PageOffset; | |
| /* print addresses of all blocks on current page */ | |
| fputs(" Data: ", stdout); | |
| while (ActData != ActEndOfPage) { | |
| int column; | |
| fputs("\n\t\t", stdout); | |
| for (column = 0; column < 6; column++) { | |
| printf("%p ", ActData); | |
| ActData = (char *)ActData + BlockSize; | |
| if (ActData == ActEndOfPage) { | |
| break; | |
| } | |
| } | |
| } | |
| /* go to next page in list */ | |
| ActPage = *((POINTER *)ActPage); | |
| } | |
| /* print allocated and freed blocks of size i */ | |
| memory_PrintAllocatedBlocks(i); | |
| memory_PrintFreedBlocks(i); | |
| } | |
| } | |
| #ifdef CHECK | |
| /* print allocated blocks of size >= memory_DYNMAXSIZE */ | |
| printf("\n\n Allocated blocks of size >= %d\n", | |
| memory__DYNMAXSIZE); | |
| memory_PrintAllocatedBigBlocks(); | |
| #endif | |
| #endif | |
| } | |
| void memory_PrintLeaks(void) | |
| /************************************************************** | |
| INPUT : None. | |
| RETURNS: None. | |
| SUMMARY: Prints addresses of all allocated blocks. Should be | |
| used at the end of a program before the call to | |
| memory_FreeAllMem. | |
| ***************************************************************/ | |
| { | |
| #ifndef NO_MEMORY_MANAGEMENT | |
| POINTER ActPage; /* current page */ | |
| POINTER ActNext; /* next fresh block on current page */ | |
| POINTER ActEndOfPage; /* end of current page */ | |
| MEMORY_RESOURCE *Resource; /* current resource */ | |
| unsigned int Size; /* current size */ | |
| unsigned int BlockSize; /* total block size */ | |
| /* Check if some memory is still allocated */ | |
| if (memory_UsedBytes() != 0L) { | |
| /* If that´s true, print all allocated blocks */ | |
| /* Start with blocks administered by our memory management */ | |
| for (Size = 1; Size < memory__DYNMAXSIZE; Size++) { | |
| /* Initialize variables for current block size */ | |
| Resource = memory_ARRAY[Size]; | |
| ActPage = Resource->page; | |
| ActNext = Resource->next; | |
| ActEndOfPage = Resource->end_of_page; | |
| BlockSize = Resource->total_size; | |
| /* Check if there were any requests for | |
| memory blocks of that size */ | |
| if (*((int *)ActPage) != EOF) { | |
| /* if that´s true, browse through all blocks on all pages | |
| to find a block that is still allocated | |
| */ | |
| #ifdef CHECK | |
| POINTER ActData; | |
| BOOL LeakFound; | |
| LeakFound = FALSE; | |
| while (*((int *)ActPage) != EOF) { | |
| /* search through all pages for a block that is still allocated */ | |
| ActData = (char *)ActPage + sizeof(POINTER) + memory_OFFSET; | |
| ActEndOfPage = (char *)ActPage + Resource->offset; | |
| while (ActData != ActNext && ActData != ActEndOfPage) { | |
| if (memory_GetBlockStatus(ActData) == memory_MAGICMALLOC) { | |
| LeakFound = TRUE; | |
| break; | |
| } | |
| ActData = (char *)ActData + BlockSize; | |
| } | |
| if (LeakFound) { | |
| /* if we have found one, than call memory_PrintAllocatedBlocks | |
| to print its address */ | |
| printf("\n\n Leaked blocks of size %d:", Size); | |
| memory_PrintAllocatedBlocks(Size); | |
| putchar('\n'); | |
| /* since memory_PrintAllocatedblocks prints | |
| *all* allocated blocks of specific size, we can | |
| break out of the while loop | |
| */ | |
| break; | |
| } | |
| else { | |
| /* go to next page */ | |
| ActPage = *((POINTER *)ActPage); | |
| } | |
| } | |
| #endif | |
| } | |
| } | |
| #ifdef CHECK | |
| /* Print allocated blocks of size >= memory__DYNMAXSIZE */ | |
| if (memory_BIGBLOCKS != NULL) { | |
| printf("\n\n Leaked blocks of size >= %d\n", | |
| memory__DYNMAXSIZE); | |
| memory_PrintAllocatedBigBlocks(); | |
| putchar('\n'); | |
| } | |
| #endif | |
| } | |
| #endif | |
| } |