| /*---------------------------------------------------------------------------* |
| * pmemfixed.c * |
| * * |
| * Copyright 2007, 2008 Nuance Communciations, Inc. * |
| * * |
| * Licensed under the Apache License, Version 2.0 (the 'License'); * |
| * you may not use this file except in compliance with the License. * |
| * * |
| * You may obtain a copy of the License at * |
| * http://www.apache.org/licenses/LICENSE-2.0 * |
| * * |
| * Unless required by applicable law or agreed to in writing, software * |
| * distributed under the License is distributed on an 'AS IS' BASIS, * |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * |
| * See the License for the specific language governing permissions and * |
| * limitations under the License. * |
| * * |
| *---------------------------------------------------------------------------*/ |
| |
| |
| |
| #include "pmemory.h" |
| #include "plog.h" |
| |
| #undef malloc |
| #undef calloc |
| #undef realloc |
| #undef free |
| |
| |
| #ifdef PORTABLE_FIXED_SIZE_MEM_BLOCK_SCHEME |
| |
| /* |
| How does the Fixed Size Memory Block Manager Work? |
| The memory manager manages an unlimited number of pools, each containing a linked list |
| of free memory blocks of a fixed size. The memory pools are ordered in increasing block |
| size, eg. pool # 0 contains 4 byte memory blocks, pool # 1 contains 8, etc. Each memory |
| block consists of a header and body. The header (which is currently 8 bytes long) is used |
| to store the address of the next free memory block in the linked list, and to store the |
| memory block's pool ID (this is used by the free function to determine which pool the block |
| originated from). The body is simply the usable memory. Whenever the application requests |
| memory of a given size, the memory manager selects the appropriate memory pool which contain |
| blocks large enough to satisfy the request. The memory manager removes a block from the |
| linked list and returns the address of the memory block body. If there are no blocks |
| available in the pool, then more blocks are created (if there is memory available); the |
| number created is configurable. If it is not possible to create more blocks, then the |
| memory manager searches the remaining pools in the sequence until it finds a free block or |
| it runs out of pools (in this case it will return a null pointer to the calling code). |
| |
| How is the memory space allocated to the fixed block pools? |
| At start-up the memory manager requests one large memory block from the system (the size is |
| defined by #define MEM_SIZE). This memory is used to a) create the fixed size memory pools |
| (each contain the initial number defined in the code) and b) to create extra memory blocks |
| each time a particular pool has been exhausted (the number created is configurable for each |
| memory pool also). Once all of this memory has been used up it is also possible to make |
| further requests to the system for more memory (to create more fixed memory blocks); this |
| feature is switched on using the compilation flag ALLOW_ADDITIONAL_SYS_MEM_ALLOCS. Note |
| that once memory blocks have been added to a memory pool they cannot be removed and reused |
| in another, eg a 0.5 MByte memory block could not be removed from its 0.5 Mbyte pool in |
| order to create smaller 4 byte blocks in the 4byte block pool. |
| |
| How is the large memory block from the system allocated? |
| It can be allocated in one of three ways depending on compile time definitions. If you define |
| STATIC_MEMORY_POOL, it's allocated as a static array. If you define RTXC_PARTITION_MEMORY, |
| it's allocated from the HEAP_MAP memory partition. If you don't define anything, it's allocated |
| using the system malloc call. Of course, RTXC_PARTITION should only be defined on when you building |
| for the RTXC operating system. |
| |
| If STATIC_MEMORY_POOL or RTXC_PARTITION is defined, you cannot define ALLOW_ADDITIONAL_SYS_MEM_ALLOCS. |
| |
| Key Points: |
| 1. Configurable memory block sizes (not restricted to power of 2 sizes). |
| 2. Best fit algorith. |
| 3. Dynamically increases the pool sizes (from an initial number). |
| 4. Can limit the total heap size. |
| 5. Configurable initial pool sizes. |
| 6. Allow additional system memory allocations in order to increase the pool sizes when the |
| 'heap' limit has been reached. |
| 7. Doesn't support block consolidation, and reuse across pools. |
| |
| */ |
| |
| /*************************** Header Files *************************************/ |
| |
| #ifdef RTXC_PARTITION_MEMORY |
| #include <rtxcapi.h> |
| /* TODO - When rtxcgen is run, it will create this header file that should contain |
| * identifiers for various memory partitions that we will be using. For now, in order |
| * to get a compile, define a partition identifier. |
| */ |
| #define HEAP_MAP 1 |
| |
| #endif |
| |
| #ifdef __cplusplus |
| extern "C" |
| { |
| #endif |
| |
| |
| |
| /*************************** Macros Definitions *******************************/ |
| /* All of these should be defined on the command line |
| * #define MEM_MGR_STATS |
| * #define ALLOW_ADDITIONAL_SYS_MEM_ALLOCS |
| * #define ALLOW_POOL_GROWTHS |
| * #define MEM_SIZE |
| */ |
| |
| /* |
| #if (defined(STATIC_MEMORY_POOL) || defined(RTXC_PARTITION_MEMORY)) && defined(ALLOW_ADDITIONAL_SYS_MEM_ALLOCS) |
| #error Can't allocate additional memory blocks from the system. |
| #endif |
| */ |
| /* TODO: Need to figure out a good size for this. */ |
| /* This had better be the same as the block in HEAP_MAP as defined when building RTXC. */ |
| |
| #ifndef MEM_SIZE |
| /* If not defined on the command line, use a default value of 10 megabytes for the heap. */ |
| #define MEM_SIZE (10 * 1024 * 1024) /* 10 MBytes */ |
| #endif |
| |
| #define MEM_BLOCK_HDR 8 /* (bytes): 16 bit Pool ID, 16 bit signature, 32 bit next block pointer */ |
| #define MEM_POOL_ID_OFFSET 0 |
| #define NEXT_BLOCK_PTR_OFFSET 1 /* (no. of 4 byte words) */ |
| #define MEM_BLOCK_HDR_OFFSET 2 /* (no. of 4 byte words) */ |
| |
| #define MEM_POOL_ID_MASK 0x000000FF |
| #define MEM_REQ_SIZE_MASK 0xFFFFFF00 |
| #define MEM_REQ_SIZE_BIT_SHIFT 8 |
| |
| |
| |
| /*************************** Type Defs ****************************************/ |
| |
| typedef struct |
| { |
| unsigned int accReqSize; |
| unsigned int maxReqSize; |
| unsigned int allocated; |
| unsigned int accAllocated; |
| unsigned int accFreed; |
| unsigned int max_alloc; |
| } |
| MEM_STATS; |
| |
| |
| |
| /*************************** Global Variables *********************************/ |
| |
| int memPoolsInitialised = 0; |
| |
| unsigned int memBlockSize[] = { 4, 8, 12, 16, 20, 24, 28, 32, 36, 40, 44, 48, 52, 56, 60, 64, 128, 256, 512, 1024, 2048, 4096, 8192, 16384, 32768, 65536, 131072, 262144, 524288 }; |
| /*unsigned int memBlockNum[] = { 400, 1600, 17000, 8192, 13440, 512, 384, 4352, 900, 7000, 256, 2048, 1024, 128, 128, 256, 6000, 2500, 380, 170, 85, 40, 30, 120, 40, 2, 1, 2, 2 };*/ |
| unsigned int memBlockNum[] = { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; |
| unsigned int memBlkGrowthNum[] = { 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 128, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1 }; |
| |
| #define NUM_OF_POOLS (sizeof( memBlockSize ) / sizeof( unsigned int )) |
| |
| static unsigned int memBlkGrowths[NUM_OF_POOLS]; |
| |
| #ifdef STATIC_MEMORY_POOL |
| static char pHeap[MEM_SIZE]; |
| #else |
| static char *pHeap; |
| #endif |
| static char* pReservedHeapMem; |
| static char* pMemPools[NUM_OF_POOLS]; |
| |
| static unsigned int initialHeapSize = MEM_SIZE; |
| static unsigned int usedHeapSize = 0; |
| static unsigned int reservedHeapSize = 0; |
| static unsigned int totalSystemAllocMem = 0; |
| static unsigned int numOfSystemAllocs = 0; |
| |
| static MEM_STATS memStats[NUM_OF_POOLS]; |
| static unsigned int allocatedMem = 0; |
| static unsigned int maxAllocMem = 0; |
| |
| |
| |
| /*************************** Function Prototypes ******************************/ |
| |
| void initAllMemPools(void); |
| char* initMemPool(int poolId, int memBlockSize, int numOfMemBlocks, char** startAddress); |
| void* myMalloc(size_t size); |
| void myFree(void* ptr); |
| void displayMemStats(void); |
| void increaseMemPoolSize(unsigned int poolId); |
| |
| |
| |
| /*************************** Function Definitions *****************************/ |
| |
| /******************************************************************************* |
| * |
| * Function: PortMallocInit |
| * |
| * Args: void |
| * |
| * Returns: void |
| * |
| * Description: API function which initialises the fixed size memory pools. Can |
| * be called multiple times in a session, but is only effective the |
| * first time it is called. |
| * |
| *******************************************************************************/ |
| |
| void PortMallocInit(void) |
| { |
| if (0 == memPoolsInitialised) |
| { |
| initAllMemPools(); |
| } |
| } |
| |
| |
| |
| |
| |
| int PortMallocGetMaxMemUsed(void) |
| { |
| return (int)maxAllocMem; |
| } |
| |
| |
| |
| /******************************************************************************* |
| * |
| * Function: PortMallocSetPoolSize |
| * |
| * Args: Pool size (size_t) |
| * |
| * Returns: void |
| * |
| * Description: API function used to set the initial heap size. Note this can be |
| * called at any time, but is only effective if the memory manager |
| * has not already been initialised. |
| * |
| *******************************************************************************/ |
| |
| void PortMallocSetPoolSize(size_t size) |
| { |
| #if !defined(STATIC_MEMORY_POOL) && !defined(RTXC_PARTITION_MEMORY) |
| if (!memPoolsInitialised) |
| { |
| initialHeapSize = (unsigned int)size; |
| } |
| #else |
| (void)size; |
| #endif |
| } |
| |
| |
| |
| /******************************************************************************* |
| * |
| * Function: PortMallocGetPoolSize |
| * |
| * Args: void |
| * |
| * Returns: Pool Size (int) |
| * |
| * Description: API function to return the initial heap size. |
| * |
| *******************************************************************************/ |
| |
| int PortMallocGetPoolSize(void) |
| { |
| return (int)initialHeapSize; |
| } |
| |
| |
| |
| /******************************************************************************* |
| * |
| * Function: initAllMemPools |
| * |
| * Args: void |
| * |
| * Returns: void |
| * |
| * Description: Internal function which is used to initialise all of the |
| * memory pools. Note it can be called many times but is only |
| * effective the first time it is called. |
| * |
| *******************************************************************************/ |
| |
| void initAllMemPools(void) |
| { |
| char *availableMemStartAddress; |
| |
| if (0 == memPoolsInitialised) |
| { |
| int ii; |
| |
| /* Calculate the required heap size */ |
| for (ii = 0; ii < NUM_OF_POOLS; ii++) |
| { |
| usedHeapSize += (memBlockSize[ii] + MEM_BLOCK_HDR) * memBlockNum[ii]; |
| } |
| |
| if (initialHeapSize < usedHeapSize) |
| { |
| /* Insuffucient heap memory; abort initialisation */ |
| return; |
| } |
| |
| |
| #if defined(STATIC_MEMORY_POOL) |
| /* pHead has already been allocated, statically. Don't need to do anything. */ |
| #elif defined(RTXC_PARTITION_MEMORY) |
| /* Grab the one and only block in HEAP_MAP. */ |
| pHeap = KS_alloc(HEAP_MAP); |
| /* MEM_SIZE has better equal the size of HEAP_MAP's block. */ |
| PORT_ASSERT(MEM_SIZE == KS_inqmap(HEAP_MAP)); |
| #else |
| /* Use the system malloc for heap allocation. */ |
| |
| pHeap = (char*)malloc(initialHeapSize); |
| #endif |
| if (0 == pHeap) |
| { |
| /* Unable to get memory for heap; abort initialisation */ |
| return; |
| } |
| |
| totalSystemAllocMem = initialHeapSize; |
| numOfSystemAllocs++; |
| reservedHeapSize = initialHeapSize - usedHeapSize; |
| |
| /* Initialise each memory pool */ |
| availableMemStartAddress = pHeap; |
| |
| for (ii = 0; ii < NUM_OF_POOLS; ii++) |
| { |
| pMemPools[ii] = 0; |
| |
| if (0 != memBlockNum[ii]) |
| { |
| pMemPools[ii] = initMemPool(ii, memBlockSize[ii] + MEM_BLOCK_HDR, memBlockNum[ii], &availableMemStartAddress); |
| } |
| } |
| |
| pReservedHeapMem = availableMemStartAddress; |
| |
| memPoolsInitialised = 1; |
| } |
| } |
| |
| |
| |
| /******************************************************************************* |
| * |
| * Function: initMemPool |
| * |
| * Args: Pool ID (int), Memory Block Size (int), Number of Memory Blocks |
| * (int), Heap Memory Start Address (char**) |
| * |
| * Returns: Memory Pool Start Address (char*) |
| * |
| * Description: Internal function used to fill a specified memory pool with a |
| * specified number of memory blocks of a specified size. The heap |
| * memory start address is adjusted to point to the next available |
| * memory following the newly created pool. |
| * |
| *******************************************************************************/ |
| |
| char* initMemPool(int poolId, int memBlockSize, int numOfMemBlocks, char** startAddress) |
| { |
| char* pPrevMemBlock = 0; |
| char* pCurrMemBlock = 0; |
| char* pStartMemPool = 0; |
| int ii; |
| |
| for (ii = 0; ii < numOfMemBlocks; ii++) |
| { |
| pCurrMemBlock = &((*startAddress)[ii*memBlockSize]); |
| |
| *((unsigned int*)pCurrMemBlock) = poolId; |
| |
| if (0 != pPrevMemBlock) |
| { |
| ((unsigned int*)pPrevMemBlock)[NEXT_BLOCK_PTR_OFFSET] = (unsigned int)pCurrMemBlock; |
| } |
| |
| pPrevMemBlock = pCurrMemBlock; |
| } |
| |
| ((unsigned int*)pPrevMemBlock)[NEXT_BLOCK_PTR_OFFSET] = 0; |
| |
| pStartMemPool = *startAddress; |
| |
| *startAddress = (*startAddress) + (ii * memBlockSize); |
| |
| return pStartMemPool; |
| } |
| |
| |
| |
| /******************************************************************************* |
| * |
| * Function: PortMalloc |
| * |
| * Args: Size (size_t) |
| * |
| * Returns: Pointer to memory block (void*) |
| * |
| * Description: API function which is used by the application to request memory. |
| * A null pointer is returned if the memory manager is unable to |
| * satisfy the request. |
| * |
| *******************************************************************************/ |
| |
| void* PortMalloc(size_t size) |
| { |
| int poolId; |
| char *pMemBlock; |
| int ii; |
| |
| /* Make sure the memory manager has been initialised */ |
| if (0 == memPoolsInitialised) |
| { |
| initAllMemPools(); |
| } |
| |
| poolId = NUM_OF_POOLS; |
| pMemBlock = 0; |
| |
| /* Find the best fit memory block */ |
| for (ii = 0; ii < NUM_OF_POOLS; ii++) |
| { |
| if (memBlockSize[ii] >= size) |
| { |
| poolId = ii; |
| |
| break; |
| } |
| } |
| |
| /* Ensure that the requested size is not larger than the largest block size */ |
| if (NUM_OF_POOLS > poolId) |
| { |
| /* Search the selected memory pool for a memory block; if there are none |
| then try to create some more blocks. If this is not possible then |
| search the next largest memory block pool. Repeat until either a block |
| is found, or there are no pools left */ |
| for (ii = poolId; ii < NUM_OF_POOLS; ii++) |
| { |
| #ifdef ALLOW_POOL_GROWTHS |
| /* If there are no blocks left, try to create some more */ |
| if (0 == pMemPools[ii]) |
| { |
| increaseMemPoolSize(ii); |
| } |
| #endif /* ALLOW_POOL_GROWTHS */ |
| |
| if (0 != pMemPools[ii]) |
| { |
| /* Remove the memory block from the pool linked-list */ |
| pMemBlock = pMemPools[ii]; |
| |
| pMemPools[ii] = (char*)(((unsigned int*)pMemBlock)[NEXT_BLOCK_PTR_OFFSET]); |
| |
| #ifdef MEM_MGR_STATS |
| /* Record the requested size in the memory block header - this is used |
| by PortFree to determine how much requested memory has been free'd */ |
| *((unsigned int*)pMemBlock) = ii | (size << MEM_REQ_SIZE_BIT_SHIFT); |
| #endif /* MEM_MGR_STATS */ |
| |
| /* Adjust the memory block pointer to point to the useful portion of the |
| memory block, ie beyond the header */ |
| pMemBlock = pMemBlock + MEM_BLOCK_HDR; |
| |
| #ifdef MEM_MGR_STATS |
| /* Update the memory statistics */ |
| allocatedMem += size; |
| |
| if (allocatedMem > maxAllocMem) |
| { |
| maxAllocMem = allocatedMem; |
| } |
| |
| memStats[ii].accReqSize += size; |
| memStats[ii].accAllocated++; |
| memStats[ii].allocated++; |
| |
| if (memStats[ii].maxReqSize < size) |
| { |
| memStats[ii].maxReqSize = size; |
| } |
| |
| if (memStats[ii].allocated > memStats[ii].max_alloc) |
| { |
| memStats[ii].max_alloc = memStats[ii].allocated; |
| } |
| #endif /* MEM_MGR_STATS */ |
| break; |
| } |
| } |
| } |
| |
| return (void*)pMemBlock; |
| } |
| |
| |
| #ifdef ALLOW_POOL_GROWTHS |
| /******************************************************************************* |
| * |
| * Function: increaseMemPoolSize |
| * |
| * Args: Pool ID (unsigned int) |
| * |
| * Returns: void |
| * |
| * Description: Increases the number of blocks in a given pool by the number |
| * specified in the array memBlkGrowthNum if there is memory |
| * available. Memory is allocated from the heap reserve if |
| * availabe, else it is requested from the system (if the |
| * compilation flag ALLOW_ADDITIONAL_SYS_MEM_ALLOCS is defined. If |
| * there is insufficient memory then the operation is aborted |
| * without notification to the calling code. |
| * |
| *******************************************************************************/ |
| |
| void increaseMemPoolSize(unsigned int poolId) |
| { |
| unsigned int requiredMemSize = memBlkGrowthNum[poolId] * (memBlockSize[poolId] + MEM_BLOCK_HDR); |
| |
| /* See if there is enough heap reserve memory */ |
| if (requiredMemSize <= reservedHeapSize) |
| { |
| /* We're in luck; there's enough space */ |
| pMemPools[poolId] = initMemPool(poolId, memBlockSize[poolId] + MEM_BLOCK_HDR, memBlkGrowthNum[poolId], &pReservedHeapMem); |
| |
| memBlockNum[poolId] += memBlkGrowthNum[poolId]; |
| |
| reservedHeapSize -= requiredMemSize; |
| usedHeapSize += requiredMemSize; |
| |
| #ifdef MEM_MGR_STATS |
| memBlkGrowths[poolId]++; |
| #endif /* MEM_MGR_STATS */ |
| } |
| #ifdef ALLOW_ADDITIONAL_SYS_MEM_ALLOCS |
| else |
| { |
| /* There's not enough memory in the heap reserve, so request it from the system */ |
| char* pStartAddress = (char*)malloc(requiredMemSize); |
| |
| if (0 != pStartAddress) |
| { |
| /* The system has allocated some memory, so let's make some more blocks */ |
| pMemPools[poolId] = initMemPool(poolId, memBlockSize[poolId] + MEM_BLOCK_HDR, memBlkGrowthNum[poolId], &pStartAddress); |
| |
| memBlockNum[poolId] += memBlkGrowthNum[poolId]; |
| |
| totalSystemAllocMem += requiredMemSize; |
| numOfSystemAllocs++; |
| |
| #ifdef MEM_MGR_STATS |
| memBlkGrowths[poolId]++; |
| #endif /* MEM_MGR_STATS */ |
| } |
| } |
| #endif /* ALLOW_ADDITIONAL_SYS_MEM_ALLOCS */ |
| } |
| #endif /* ALLOW_POOL_GROWTHS */ |
| |
| |
| |
| /******************************************************************************* |
| * |
| * Function: PortFree |
| * |
| * Args: Memory Block Pointer (void*) |
| * |
| * Returns: void |
| * |
| * Description: API function used by the application code to return a memory |
| * block to the appropriate pool. Note that this function is not |
| * able to handle null or stale memory block pointers; calling this |
| * function under these conditions will result in unpredictable |
| * behavior. |
| * |
| *******************************************************************************/ |
| |
| void PortFree(void* pMem) |
| { |
| unsigned int tmpVal; |
| unsigned char poolId; |
| char* pCurrentHead; |
| #ifdef MEM_MGR_STATS |
| unsigned int reqMemSize; |
| #endif |
| |
| /* What is the memory block pool id ? */ |
| tmpVal = ((unsigned int*)pMem)[-MEM_BLOCK_HDR_OFFSET+MEM_POOL_ID_OFFSET]; |
| poolId = tmpVal & MEM_POOL_ID_MASK; |
| |
| /* Add the memory block to the appropriate pool */ |
| pCurrentHead = pMemPools[poolId]; |
| ((unsigned int*)pMem)[-MEM_BLOCK_HDR_OFFSET+NEXT_BLOCK_PTR_OFFSET] = (unsigned int)pCurrentHead; |
| pMemPools[poolId] = (char*) & (((unsigned int*)pMem)[-MEM_BLOCK_HDR_OFFSET]); |
| |
| #ifdef MEM_MGR_STATS |
| /* What was the requested memory size ? */ |
| reqMemSize = tmpVal >> MEM_REQ_SIZE_BIT_SHIFT; |
| |
| allocatedMem -= reqMemSize; |
| |
| PORT_ASSERT(allocatedMem >= 0); |
| |
| memStats[poolId].accFreed++; |
| memStats[poolId].allocated--; |
| #endif /* MEM_MGR_STATS */ |
| } |
| |
| |
| |
| /******************************************************************************* |
| * |
| * Function: displayMemStats |
| * |
| * Args: void |
| * |
| * Returns: void |
| * |
| * Description: API function used to display the overall memory and individual |
| * memory pool statistics to standard output. |
| * |
| *******************************************************************************/ |
| |
| void displayMemStats(void) |
| { |
| unsigned int totBNum = 0; |
| unsigned int totGrowths = 0; |
| unsigned int totAlloc = 0; |
| unsigned int totAccAlloc = 0; |
| unsigned int totAccFreed = 0; |
| unsigned int totMaxAlloc = 0; |
| unsigned int totMemWithOH = 0; |
| unsigned int totMem = 0; |
| unsigned int bytesAllocWithOH = 0; |
| unsigned int bytesAlloc = 0; |
| unsigned int maxBytesAllocWithOH = 0; |
| unsigned int maxBytesAlloc = 0; |
| unsigned int ii; |
| |
| printf("\nPool ID BlkSz AvReqSz MaxReqSz NumBlk Growths Alloc AccAlloc AccFreed MaxAlloc Alloc(b) MaxA(b)\n"); |
| printf("--------------------------------------------------------------------------------------------------------\n"); |
| |
| for (ii = 0; ii < NUM_OF_POOLS; ii++) |
| { |
| unsigned int avReqSize = 0; |
| |
| if (0 != memStats[ii].accAllocated) |
| { |
| avReqSize = memStats[ii].accReqSize / memStats[ii].accAllocated; |
| } |
| |
| printf(" %4i %6i %6i %6i %7i %7i %7i %7i %7i %7i %8i %8i\n", ii, memBlockSize[ii], avReqSize, memStats[ii].maxReqSize, memBlockNum[ii], memBlkGrowths[ii], memStats[ii].allocated, memStats[ii].accAllocated, memStats[ii].accFreed, memStats[ii].max_alloc, (memBlockSize[ii]*memStats[ii].allocated), (memBlockSize[ii]*memStats[ii].max_alloc)); |
| |
| totBNum += memBlockNum[ii]; |
| totGrowths += memBlkGrowths[ii]; |
| totAlloc += memStats[ii].allocated; |
| totAccAlloc += memStats[ii].accAllocated; |
| totAccFreed += memStats[ii].accFreed; |
| totMaxAlloc += memStats[ii].max_alloc; |
| |
| totMemWithOH += (memBlockSize[ii] + MEM_BLOCK_HDR) * memBlockNum[ii]; |
| totMem += memBlockSize[ii] * memBlockNum[ii]; |
| bytesAllocWithOH += memStats[ii].allocated * (memBlockSize[ii] + MEM_BLOCK_HDR); |
| bytesAlloc += memStats[ii].allocated * memBlockSize[ii]; |
| maxBytesAllocWithOH += memStats[ii].max_alloc * (memBlockSize[ii] + MEM_BLOCK_HDR); |
| maxBytesAlloc += memStats[ii].max_alloc * memBlockSize[ii]; |
| } |
| |
| printf("--------------------------------------------------------------------------------------------------------\n"); |
| printf("Total %7i %7i %7i %7i %7i %7i %8i %8i\n\n", totBNum, totGrowths, totAlloc, totAccAlloc, totAccFreed, totMaxAlloc, bytesAlloc, maxBytesAlloc); |
| printf("Total Memory %9i bytes\n", totMemWithOH); |
| printf("Total Memory %9i bytes (without overhead)\n", totMem); |
| printf("Allocated Memory %9i bytes\n", bytesAllocWithOH); |
| printf("Allocated Memory %9i bytes (without overhead)\n", bytesAlloc); |
| printf("Max Alloc Memory %9i bytes\n", maxBytesAllocWithOH); |
| printf("Max Alloc Memory %9i bytes (without overhead)\n", maxBytesAlloc); |
| printf("\nReq Alloc Memory %9i bytes\n", allocatedMem); |
| printf("Max Rq Alloc Mem %9i bytes\n\n", maxAllocMem); |
| |
| printf("Used Heap Size %9i bytes\n", usedHeapSize); |
| printf("Reserved Heap %9i bytes\n", reservedHeapSize); |
| printf("Total Sys Alloc %9i bytes\n", totalSystemAllocMem); |
| printf("Num of Sys Alloc %9i\n", numOfSystemAllocs); |
| |
| printf("\n"); |
| } |
| |
| |
| |
| #ifdef __cplusplus |
| } /* end extern "C" */ |
| #endif |
| |
| |
| #endif /* FIXED_SIZE_MEM_BLOCK_SCHEME */ |
