/*----------------------------------------------------------------------- File : clb_memory.c Author: Stephan Schulz Memory management. The implemented routines are very simple, because they make use of the standard memory management for reorganization. Copyright 1998, 1999 by the author. This code is released under the GNU General Public Licence and the GNU Lesser General Public License. See the file COPYING in the main E directory for details.. Run "eprover -h" for contact information. Changes <1> Thu Aug 14 10:00:35 MET DST 1997 new -----------------------------------------------------------------------*/ #include "clb_newmem.h" /*-----------------------------------------------------------------------*/ /* Globale Variable */ /*-----------------------------------------------------------------------*/ /* This global variable is set whenever malloc() failed and triggered a free memory reorganization. User programs may examine this variable to take certain measures (and may reset it if they think that they freed significant amounts of memory). However, this is somewhat discouraged - do you really want your program to depend in pretty complex ways on uncontrolable features like the amount of free memory available to your process? _I_ only use it for some measurements ;-) StS */ bool MemIsLow = false; Mem_p free_mem_list[MEM_ARR_SIZE] = {NULL}; #ifdef CLB_MEMORY_DEBUG long size_malloc_mem = 0; long size_malloc_count = 0; long size_free_mem = 0; long size_free_count = 0; long clb_free_count = 0; long secure_malloc_count = 0; long secure_malloc_mem = 0; long secure_realloc_count = 0; long secure_realloc_m_count = 0; long secure_realloc_f_count = 0; #endif /*-----------------------------------------------------------------------*/ /* Exportierte Funktionen */ /*-----------------------------------------------------------------------*/ /*----------------------------------------------------------------------- // // Function: MemFlushFreeList() // // Returns all memory kept in free_mem_list[] to the operation // system. This is useful if a very different memory access pattern // is expected (SizeFree() never reorganizes the memory // automatically). // // Global Variables: free_mem_list[] // // Side Effects : Memory operations // /----------------------------------------------------------------------*/ void MemFlushFreeList(void) { VERBOUT("MemFlushFreeList() called - this is a dummy in the new memory handler\n"); } /*----------------------------------------------------------------------- // // Function: SecureMalloc() // // Returns a pointer to an unused memory block sized size. If // possible, a fresh block is allocated, if not, the // reorganization of free_mem_list is triggered, if still no memory // is available, an error will be produced. // // Global Variables: free_mem_list // // Side Effects : Memory operations, possibly error // /----------------------------------------------------------------------*/ void* SecureMalloc(int size) { void* handle; #ifdef CLB_MEMORY_DEBUG secure_malloc_count++; secure_malloc_mem += size; #endif handle = (void*)malloc(size); if(!handle) { /* malloc has no memory left */ MemIsLow = true; MemFlushFreeList(); /* Return own freelist */ handle = (void*)malloc(size); if(!handle) { /* Still nothing...*/ #ifdef PRINT_SOMEERRORS_STDOUT PrintRusage(stdout); fprintf(stdout, "# Failure: Resource limit exceeded (memory)\n"); #endif Error("Out of Memory", OUT_OF_MEMORY); } } return handle; } /*------------------------------------------------------------------------- // // Function: SecureRealloc() // // Imitates realloc, but reorganizes free_mem_list to get new memory // if the block has to be moved and no memory is available. Will // terminate with OUT_OF_MEMORY if no memory is found. // // Global Variables: - // // Side Effect : Via SecureMalloc() // //-----------------------------------------------------------------------*/ void* SecureRealloc(void *ptr, int size) { void* handle; #ifdef CLB_MEMORY_DEBUG secure_realloc_count++; if(ptr && !size) { secure_realloc_f_count++; } else if(!ptr && size) { secure_realloc_m_count++; } #endif /* SunOS realloc() is broken, so here is a stupid workaround...*/ handle = ptr?realloc(ptr,size):malloc(size); if(!handle && size!=0) { MemFlushFreeList(); handle = ptr?realloc(ptr,size):malloc(size); if(!handle) { /* Still nothing...*/ #ifdef PRINT_SOMEERRORS_STDOUT PrintRusage(stdout); fprintf(stdout, "# Failure: Resource limit exceeded (memory)\n"); #endif Error("Out of Memory", OUT_OF_MEMORY); } } return handle; } /*----------------------------------------------------------------------- // // Function: SizeMallocReal() // // Returns a block of memory sized size using the internal // free-list. This block is not freeable with free(), but otherwise // should behave like a normal malloc'ed block. // // Global Variables: free_mem_list[] // // Side Effects : Memory operations // /----------------------------------------------------------------------*/ void* SizeMallocReal(int size) { Mem_p handle; int mem_index; size = MAX(size, sizeof(MemCell)); mem_index = (size+MEM_ALIGN-1)/MEM_ALIGN; assert(mem_index > 0); if(mem_indexnext = NULL; assert((free_mem_list[mem_index]->test = MEM_FREE_PATTERN, true)); } } assert(free_mem_list[mem_index]->test = MEM_FREE_PATTERN); assert((free_mem_list[mem_index]->test = MEM_RSET_PATTERN, true)); handle = (void*)(free_mem_list[mem_index]); assert(handle); free_mem_list[mem_index] = free_mem_list[mem_index]->next; } else { handle = SecureMalloc(size); } #ifdef CLB_MEMORY_DEBUG size_malloc_mem+=size; size_malloc_count++; #endif #ifdef CLB_MEMORY_DEBUG2 printf("\nBlock %p A: size %d\n", handle, size); #endif return handle; } /*----------------------------------------------------------------------- // // Function: SizeFreeReal() // // Returns a block sized size. Note: size has to be exact - you // should only give blocks to SizeFree() that have been allocated // with malloc(size) or SizeMalloc(size). Giving blocks that are to // big wastes memory, blocks that are to small will result in more // serious trouble (segmentation faults). // // Global Variables: free_mem_list[] // // Side Effects : Memory operations // /----------------------------------------------------------------------*/ void SizeFreeReal(void* junk, int size) { int mem_index; assert(junk!=NULL); #ifdef CLB_MEMORY_DEBUG2 printf("\nBlock %p D: size %d\n", junk, size); #endif size = MAX(size, sizeof(MemCell)); mem_index = (size+MEM_ALIGN-1)/MEM_ALIGN; if(mem_indexnext = free_mem_list[mem_index]; free_mem_list[mem_index] = (Mem_p)junk; assert(free_mem_list[mem_index]->test != MEM_FREE_PATTERN); assert(free_mem_list[mem_index]->test = MEM_FREE_PATTERN); } else { FREE(junk); } #ifdef CLB_MEMORY_DEBUG size_free_mem+=size; size_free_count++; #endif } /*----------------------------------------------------------------------- // // Function: MemAddNewChunk() // // Allocate a block of size MEM_MULTIPLIER*mem_index*MEM_ALIGN and split // it into MEM_MULTIPLIER blocks linked into // free_mem_list[index]. In other words, fill up the list of fresh // blocks of a given size. // // Global Variables: free_mem_list // // Side Effects : Memory allocation, changes free_mem_list[index] // /----------------------------------------------------------------------*/ void MemAddNewChunk(int mem_index) { Mem_p handle, old; char* block; int i, size; old = free_mem_list[mem_index]; size = mem_index*MEM_ALIGN; block = SecureMalloc(size*MEM_MULTIPLIER); free_mem_list[mem_index] = (Mem_p)block; for(i=0; i< MEM_MULTIPLIER; i++) { handle = (Mem_p)block; assert(handle->test = MEM_FREE_PATTERN); block += size; handle->next = (Mem_p)block; } handle->next = old; } /*----------------------------------------------------------------------- // // Function: SecureStrdup() // // Implements the functionality of strdup, but uses SecureMalloc() / for the memory handling. // // Global Variables: - // // Side Effects : By SecureMalloc() // /----------------------------------------------------------------------*/ char* SecureStrdup(char* source) { char* handle; handle = (char*)SecureMalloc(strlen(source)+1); strcpy(handle,source); return handle; } /*----------------------------------------------------------------------- // // Function: IntArrayAlloc() // // Return a pointer to a freshly allocated, 0-initialized block of // longs. // // Global Variables: - // // Side Effects : Memory operations // /----------------------------------------------------------------------*/ long* IntArrayAlloc(int size) { long *res; int i; res = SizeMalloc(size*sizeof(long)); for(i=0; i