| /********************************************************************** |
| * File: memblk.c (Formerly memblock.c) |
| * Description: Enhanced instrumented memory allocator implemented as a class. |
| * Author: Ray Smith |
| * Created: Tue Jan 21 17:13:39 GMT 1992 |
| * |
| * (C) Copyright 1992, Hewlett-Packard Ltd. |
| ** 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 "mfcpch.h" //precompiled headers |
| #include <stdlib.h> |
| #include <string.h> |
| #include "stderr.h" |
| #include "memryerr.h" |
| #include "hashfn.h" |
| #include "tprintf.h" |
| #include "memry.h" |
| #include "memblk.h" |
| #ifdef __UNIX__ |
| #include <signal.h> |
| #endif |
| |
| class UWREC |
| { |
| public: |
| unsigned cur_frsize; //frame size |
| unsigned cursp; //stack |
| unsigned currls; //pc space |
| unsigned currlo; //pc offset |
| unsigned curdp; //data pointer |
| unsigned toprp; //rp |
| unsigned topmrp; //mrp |
| unsigned topsr0; //sr0 |
| unsigned topsr4; //sr4 |
| unsigned r3; //gr3 |
| unsigned cur_r19; //gr19 |
| }; |
| |
| MEMUNION *free_block = NULL; //head of freelist |
| |
| #define EXTERN |
| |
| EXTERN MEM_ALLOCATOR big_mem; |
| EXTERN MEM_ALLOCATOR main_mem; |
| //heads of freelists |
| EXTERN MEMUNION *free_structs[MAX_STRUCTS]; |
| //number issued |
| EXTERN inT32 structs_in_use[MAX_STRUCTS]; |
| //number issued |
| EXTERN inT32 blocks_in_use[MAX_STRUCTS]; |
| //head of block lists |
| EXTERN MEMUNION *struct_blocks[MAX_STRUCTS]; |
| EXTERN const char *owner_names[MAX_STRUCTS][MAX_CLASSES]; |
| EXTERN inT32 owner_counts[MAX_STRUCTS][MAX_CLASSES]; |
| //no of names |
| EXTERN inT16 name_counts[MAX_STRUCTS]; |
| EXTERN inT32 free_struct_blocks; //no of free blocks |
| |
| EXTERN INT_VAR (mem_mallocdepth, 0, "Malloc stack depth to trace"); |
| EXTERN INT_VAR (mem_mallocbits, 8, "Log 2 of hash table size"); |
| EXTERN INT_VAR (mem_freedepth, 0, "Free stack dpeth to trace"); |
| EXTERN INT_VAR (mem_freebits, 8, "Log 2 of hash table size"); |
| EXTERN INT_VAR (mem_countbuckets, 16, "No of buckets for histogram"); |
| EXTERN INT_VAR (mem_checkfreq, 0, "Calls to alloc_mem between owner counts"); |
| |
| /********************************************************************** |
| * MEM_ALLOCATOR::MEM_ALLOCATOR |
| * |
| * Constructor for a memory allocator. |
| **********************************************************************/ |
| |
| void |
| MEM_ALLOCATOR::init ( //initialize |
| void *(*ext_malloc) (inT32), //external source |
| void (*ext_free) (void *), //external free |
| inT32 firstsize, //size of first block |
| inT32 lastsize, //size of last block |
| inT32 maxchunk //biggest request |
| ) { |
| blockcount = 0; |
| malloc_serial = 0; |
| topblock = NULL; |
| currblock = NULL; |
| callers = NULL; |
| malloc = ext_malloc; |
| free = ext_free; |
| maxsize = lastsize; |
| biggestblock = maxchunk; |
| totalmem = 0; |
| memsize = firstsize; |
| malloc_div_ratio = 1; |
| malloc_minor_serial = 0; |
| malloc_auto_count = 0; |
| call_bits = 0; |
| entries = 0; |
| } |
| |
| |
| /********************************************************************** |
| * MEM_ALLOCATOR::hash_caller |
| * |
| * Generate a hash code for a caller, setup the tables if necessary. |
| **********************************************************************/ |
| |
| uinT16 MEM_ALLOCATOR::hash_caller( //get hash code |
| void *addr //return address |
| ) { |
| inT32 index; //index to table |
| inT32 initial_hash; //initial index |
| |
| if (callers == NULL) |
| init_callers(); //setup table |
| //get hash code |
| initial_hash = hash (call_bits, &addr, sizeof (addr)); |
| if (initial_hash == 0) |
| initial_hash = 1; |
| index = initial_hash; |
| if (callers[index].caller != NULL && callers[index].caller != addr) { |
| do { |
| index++; |
| if (index >= entries) |
| index = 1; |
| } |
| while (callers[index].caller != NULL |
| && callers[index].caller != addr && index != initial_hash); |
| if (index == initial_hash) |
| index = 0; |
| } |
| if (callers[index].caller == NULL) { |
| if (index != 0) |
| callers[index].caller = addr; |
| if (callers[index].free_list == NULL) |
| //setup free table |
| callers[index].init_freeers (); |
| } |
| return (uinT16) index; |
| } |
| |
| |
| /********************************************************************** |
| * MALLOC_CALL::count_freeer |
| * |
| * Generate a hash code for a freeer, setup the tables if necessary. |
| * Then count the call. |
| **********************************************************************/ |
| |
| void MALLOC_CALL::count_freeer( //count calls to free |
| void *addr //return address |
| ) { |
| inT32 entries; //entries in table |
| inT32 index; //index to table |
| inT32 initial_hash; //initial index |
| |
| if (free_list == NULL) |
| init_freeers(); //setup table |
| entries = 1 << free_bits; |
| //get hash code |
| initial_hash = hash (free_bits, &addr, sizeof (addr)); |
| if (initial_hash == 0) |
| initial_hash = 1; |
| index = initial_hash; |
| if (free_list[index].freeer != NULL && free_list[index].freeer != addr) { |
| do { |
| index++; |
| if (index >= entries) |
| index = 1; |
| } |
| while (free_list[index].freeer != NULL |
| && free_list[index].freeer != addr && index != initial_hash); |
| if (index == initial_hash) |
| index = 0; |
| } |
| if (free_list[index].freeer == NULL && index != 0) { |
| free_list[index].freeer = addr; |
| } |
| free_list[index].count++; //count them |
| } |
| |
| |
| /********************************************************************** |
| * MEM_ALLOCATOR::init_callers |
| * |
| * Initialize the callers hash table. |
| **********************************************************************/ |
| |
| void MEM_ALLOCATOR::init_callers() { //setup hash table |
| inT32 depth = mem_mallocdepth; |
| |
| mem_mallocdepth.set_value (0); //can't register it |
| call_bits = mem_mallocbits; |
| entries = 1 << call_bits; |
| //make an array |
| callers = new MALLOC_CALL[entries]; |
| mem_mallocdepth.set_value (depth); |
| } |
| |
| |
| /********************************************************************** |
| * MALLOC_CALL::init_freeers |
| * |
| * Initialize the freeers hash table. |
| **********************************************************************/ |
| |
| void MALLOC_CALL::init_freeers() { //setup hash table |
| inT32 entries; //entries in table |
| inT32 depth = mem_mallocdepth; |
| |
| mem_mallocdepth.set_value (0); //can't register it |
| free_bits = mem_freebits; |
| entries = 1 << free_bits; |
| //make an array |
| free_list = new FREE_CALL[entries]; |
| mem_mallocdepth.set_value (depth); |
| } |
| |
| |
| /********************************************************************** |
| * MEM_ALLOCATOR::reduce_counts |
| * |
| * Divide all ages by 2 to get a log use of counts. |
| **********************************************************************/ |
| |
| void MEM_ALLOCATOR::reduce_counts() { //divide by 2 |
| MEMBLOCK *block; //current block |
| MEMUNION *chunk; //current chunk |
| inT32 chunksize; //size of chunk |
| inT32 blockindex; //index of block |
| |
| check_mem ("Reducing counts", JUSTCHECKS); |
| for (blockindex = 0; blockindex < blockcount; blockindex++) { |
| //current block |
| block = &memblocks[blockindex]; |
| //scan all chunks |
| for (chunk = block->blockstart; chunk != block->blockend; chunk += chunksize) { |
| chunksize = chunk->size; //size of chunk |
| if (chunksize < 0) |
| chunksize = -chunksize; //absolute size |
| chunk->age /= 2; //divide ages |
| } |
| } |
| } |
| |
| |
| /********************************************************************** |
| * MEM_ALLOCATOR::display_counts |
| * |
| * Send counts of outstanding blocks to stderr. |
| **********************************************************************/ |
| |
| void MEM_ALLOCATOR::display_counts() { //count up |
| MEMBLOCK *block; //current block |
| MEMUNION *chunk; //current chunk |
| inT32 chunksize; //size of chunk |
| inT32 blockindex; //index of block |
| inT32 buckets; //required buckets |
| inT32 bucketsize; //no in each bucket |
| inT32 callindex; //index to callers |
| inT32 freeindex; //index to freeers |
| inT32 freeentries; //table size |
| inT32 totalchunks; //total chunk counts |
| inT32 totalspace; //total mem space |
| inT32 totalpchunks; //permanent chunks |
| inT32 totalpspace; //permanent space |
| inT32 totalfrees; //total free calls |
| |
| if (callers == NULL) |
| return; //can't do anything |
| check_mem ("Displaying counts", JUSTCHECKS); |
| buckets = mem_countbuckets; |
| bucketsize = (malloc_serial - 1) / buckets + 1; |
| tprintf ("\nEach bucket covers %g counts.\n", |
| (double) bucketsize * malloc_div_ratio); |
| for (callindex = 0; callindex < entries; callindex++) { |
| if (callers[callindex].free_list != NULL) { |
| callers[callindex].counts = |
| (inT32 *) malloc (buckets * 4 * sizeof (inT32)); |
| memset (callers[callindex].counts, 0, |
| (size_t) (buckets * 4 * sizeof (inT32))); |
| } |
| } |
| for (blockindex = 0; blockindex < blockcount; blockindex++) { |
| //current block |
| block = &memblocks[blockindex]; |
| //scan all chunks |
| for (chunk = block->blockstart; chunk != block->topchunk; chunk += chunksize) { |
| chunksize = chunk->size; //size of chunk |
| if (chunksize < 0) { |
| chunksize = -chunksize; //absolute size |
| callindex = chunk->owner; |
| if (callers[callindex].counts != NULL) { |
| callers[callindex].counts[chunk->age / bucketsize * 4]++; |
| callers[callindex].counts[chunk->age / bucketsize * 4 + |
| 1] += chunksize; |
| } |
| } |
| } |
| //scan all chunks |
| for (; chunk != block->blockend; chunk += chunksize) { |
| chunksize = chunk->size; //size of chunk |
| if (chunksize < 0) { |
| chunksize = -chunksize; //absolute size |
| callindex = chunk->owner; |
| if (callers[callindex].counts != NULL) { |
| callers[callindex].counts[chunk->age / bucketsize * 4 + |
| 2]++; |
| callers[callindex].counts[chunk->age / bucketsize * 4 + |
| 3] += chunksize; |
| } |
| } |
| } |
| } |
| for (callindex = 0; callindex < entries; callindex++) { |
| if (callers[callindex].counts != NULL) { |
| for (totalspace = 0, totalchunks = 0, totalpspace = |
| 0, totalpchunks = 0, freeindex = 0; freeindex < buckets; |
| freeindex++) { |
| totalchunks += callers[callindex].counts[freeindex * 4]; |
| totalspace += callers[callindex].counts[freeindex * 4 + 1]; |
| totalpchunks += callers[callindex].counts[freeindex * 4 + 2]; |
| totalpspace += callers[callindex].counts[freeindex * 4 + 3]; |
| } |
| freeentries = 1 << callers[callindex].free_bits; |
| for (totalfrees = 0, freeindex = 0; freeindex < freeentries; |
| freeindex++) |
| totalfrees += callers[callindex].free_list[freeindex].count; |
| if (totalspace != 0 || totalfrees != 0) { |
| tprintf ("alloc_mem at %d : total held=%d(%d), frees=%d.\n", |
| callers[callindex].caller, |
| totalchunks, totalspace * sizeof (MEMUNION), |
| totalfrees); |
| } |
| if (totalspace > 0) { |
| for (freeindex = 0; freeindex < buckets; freeindex++) { |
| tprintf ("%d(%d) ", |
| callers[callindex].counts[freeindex * 4], |
| callers[callindex].counts[freeindex * 4 + |
| 1] * sizeof (MEMUNION)); |
| } |
| tprintf ("\n"); |
| } |
| if (totalfrees != 0) { |
| tprintf ("Calls to free : "); |
| for (freeindex = 0; freeindex < freeentries; freeindex++) { |
| if (callers[callindex].free_list[freeindex].count != 0) |
| tprintf ("%d : %d ", |
| callers[callindex].free_list[freeindex].freeer, |
| callers[callindex].free_list[freeindex].count); |
| } |
| tprintf ("\n"); |
| } |
| if (totalpspace != 0) { |
| tprintf ("alloc_mem_p at %d : total held=%d(%d).\n", |
| callers[callindex].caller, |
| totalpchunks, totalpspace * sizeof (MEMUNION)); |
| for (freeindex = 0; freeindex < buckets; freeindex++) { |
| tprintf ("%d(%d) ", |
| callers[callindex].counts[freeindex * 4 + 2], |
| callers[callindex].counts[freeindex * 4 + |
| 3] * sizeof (MEMUNION)); |
| } |
| tprintf ("\n"); |
| } |
| free (callers[callindex].counts); |
| callers[callindex].counts = NULL; |
| } |
| } |
| } |
| |
| |
| /********************************************************************** |
| * MEM_ALLOCATOR::check |
| * |
| * Check consistency of all memory controlled by this allocator. |
| **********************************************************************/ |
| |
| void MEM_ALLOCATOR::check( //check consistency |
| const char *string, //context message |
| inT8 level //level of check |
| ) { |
| MEMBLOCK *block; //current block |
| MEMUNION *chunk; //current chunk |
| MEMUNION *prevchunk; //previous chunk |
| inT32 chunksize; //size of chunk |
| inT32 usedcount; //no of used chunks |
| inT32 usedsize; //size of used chunks |
| inT32 freecount; //no of free chunks |
| inT32 freesize; //size of free chunks |
| inT32 biggest; //biggest free chunk |
| inT32 totusedcount; //no of used chunks |
| inT32 totusedsize; //size of used chunks |
| inT32 totfreecount; //no of free chunks |
| inT32 totfreesize; //size of free chunks |
| inT32 totbiggest; //biggest free chunk |
| inT32 totblocksize; //total size of blocks |
| inT32 chunkindex; //index of chunk |
| inT32 blockindex; //index of block |
| |
| if (level >= MEMCHECKS) |
| tprintf ("\nMEM_ALLOCATOR::check:at '%s'\n", string); |
| totusedcount = 0; //grand totals |
| totusedsize = 0; |
| totfreecount = 0; |
| totfreesize = 0; |
| totbiggest = 0; |
| totblocksize = 0; |
| for (blockindex = 0; blockindex < blockcount; blockindex++) { |
| //current block |
| block = &memblocks[blockindex]; |
| if (level >= MEMCHECKS) |
| tprintf ("Block %d:0x%x-0x%x, size=%d, top=0x%x, l=%d, u=%d\n", |
| blockindex, block->blockstart, block->blockend, |
| (block->blockend - block->blockstart) * sizeof (MEMUNION), |
| block->topchunk, block->lowerspace, block->upperspace); |
| usedcount = usedsize = 0; //zero counters |
| freecount = freesize = 0; //zero counters |
| biggest = 0; |
| //scan all chunks |
| for (chunkindex = 0, prevchunk = NULL, chunk = block->blockstart; chunk != block->blockend; chunkindex++, chunk += chunksize) { |
| chunksize = chunk->size; //size of chunk |
| if (chunksize < 0) |
| chunksize = -chunksize; //absolute size |
| if (level >= FULLMEMCHECKS) { |
| tprintf ("%5d=%8d%c caller=%d, age=%d ", (int) chunkindex, |
| chunksize * sizeof (MEMUNION), |
| chunk->size < 0 ? 'U' : 'F', chunk->owner, chunk->age); |
| if (chunkindex % 5 == 4) |
| tprintf ("\n"); |
| } |
| //illegal sizes |
| if (chunksize == 0 || chunk->size == -1 |
| //out of bounds |
| || chunk + chunksize - block->blockstart <= 0 || block->blockend - (chunk + chunksize) < 0) |
| BADMEMCHUNKS.error ("check_mem", ABORT, |
| "Block=%p, Prev chunk=%p, Chunk=%p, Size=%x", |
| block, prevchunk, chunk, |
| (int) chunk->size); |
| |
| else if (chunk->size < 0) { |
| usedcount++; //used block |
| usedsize += chunksize; |
| } |
| else { |
| freecount++; //free block |
| freesize += chunksize; |
| if (chunksize > biggest) |
| biggest = chunksize; |
| } |
| prevchunk = chunk; |
| } |
| if (level >= MEMCHECKS) { |
| if (level >= FULLMEMCHECKS) |
| tprintf ("\n"); |
| tprintf ("%d chunks in use, total size=%d bytes\n", |
| (int) usedcount, usedsize * sizeof (MEMUNION)); |
| tprintf ("%d chunks free, total size=%d bytes\n", |
| (int) freecount, freesize * sizeof (MEMUNION)); |
| tprintf ("Largest free fragment=%d bytes\n", |
| biggest * sizeof (MEMUNION)); |
| } |
| totusedcount += usedcount; //grand totals |
| totusedsize += usedsize; |
| totfreecount += freecount; |
| totfreesize += freesize; |
| if (biggest > totbiggest) |
| totbiggest = biggest; |
| totblocksize += block->blockend - block->blockstart; |
| } |
| if (level >= MEMCHECKS) { |
| tprintf ("%d total blocks in use, total size=%d bytes\n", |
| blockcount, totblocksize * sizeof (MEMUNION)); |
| tprintf ("%d total chunks in use, total size=%d bytes\n", |
| (int) totusedcount, totusedsize * sizeof (MEMUNION)); |
| tprintf ("%d total chunks free, total size=%d bytes\n", |
| (int) totfreecount, totfreesize * sizeof (MEMUNION)); |
| tprintf ("Largest free fragment=%d bytes\n", |
| totbiggest * sizeof (MEMUNION)); |
| } |
| if (level >= MEMCHECKS) |
| display_counts(); |
| } |
| |
| |
| /********************************************************************** |
| * MEM_ALLOCATOR::alloc_p |
| * |
| * Allocate permanent space which will never be returned. |
| * This space is allocated from the top end of a memory block to |
| * avoid the fragmentation which would result from alternate use |
| * of alloc_mem for permanent and temporary blocks. |
| **********************************************************************/ |
| |
| void *MEM_ALLOCATOR::alloc_p( //permanent space |
| inT32 count, //block size to allocate |
| void *caller //ptr to caller |
| ) { |
| MEMBLOCK *block; //current block |
| MEMUNION *chunk; //current chunk |
| |
| if (count < 1 || count > biggestblock) |
| //request too big |
| MEMTOOBIG.error ("alloc_mem_p", ABORT, "%d", (int) count); |
| |
| count += sizeof (MEMUNION) - 1;//round up to word |
| count /= sizeof (MEMUNION); |
| count++; //and add one |
| if (topblock == NULL) { |
| topblock = new_block (count);//get first block |
| currblock = topblock; |
| if (topblock == NULL) { |
| check_mem ("alloc_mem_p returning NULL", MEMCHECKS); |
| return NULL; |
| } |
| } |
| block = topblock; //current block |
| do { |
| chunk = block->topchunk; |
| if (chunk->size < count) |
| block = block->next; //try next block |
| } |
| //until all tried |
| while (chunk->size < count && block != topblock); |
| if (chunk->size < count) { //still no good |
| chunk = (MEMUNION *) alloc ((count - 1) * sizeof (MEMUNION), caller); |
| //try last resort |
| if (chunk != NULL) |
| return chunk; |
| check_mem ("alloc_mem_p returning NULL", MEMCHECKS); |
| return NULL; |
| } |
| block->upperspace -= count; //less above freechunk |
| if (chunk->size > count) { |
| chunk->size -= count; |
| chunk += chunk->size; |
| } |
| chunk->size = -count; //mark as in use |
| if (mem_mallocdepth > 0) { |
| set_owner(chunk, caller); |
| } |
| else { |
| chunk->owner = 0; |
| chunk->age = 0; |
| } |
| return chunk + 1; //created chunk |
| } |
| |
| |
| /********************************************************************** |
| * MEM_ALLOCATOR::alloc |
| * |
| * Return a pointer to a buffer of count bytes aligned for any type. |
| **********************************************************************/ |
| |
| void *MEM_ALLOCATOR::alloc( //get memory |
| inT32 count, //no of bytes to get |
| void *caller //ptr to caller |
| ) { |
| MEMBLOCK *block; //current block |
| MEMUNION *chunk; //current chunk |
| inT32 chunksize; //size of free chunk |
| MEMUNION *chunkstart; //start of free chunk |
| |
| if (count < 1 || count > biggestblock) |
| MEMTOOBIG.error ("alloc_mem", ABORT, "%d", (int) count); |
| //request too big |
| |
| count += sizeof (MEMUNION) - 1;//round up to word |
| count /= sizeof (MEMUNION); |
| count++; //and add one |
| if (currblock == NULL) { |
| //get first block |
| currblock = new_block (count); |
| topblock = currblock; |
| if (currblock == NULL) { |
| check_mem ("alloc_mem returning NULL", MEMCHECKS); |
| return NULL; |
| } |
| } |
| block = currblock; //current block |
| if (block->upperspace <= block->lowerspace) { |
| //restart chunklist |
| block->freechunk = block->blockstart; |
| block->upperspace += block->lowerspace; |
| block->lowerspace = 0; //correct space counts |
| } |
| chunk = block->freechunk; //current free chunk |
| if (chunk->size < count) { //big enough? |
| do { |
| //search for free chunk |
| chunk = block->find_chunk (count); |
| if (chunk->size < count) |
| block = block->next; //try next block |
| } |
| //until all tried |
| while (chunk->size < count && block != currblock); |
| if (chunk->size < count) { //still no good |
| //get a new block |
| currblock = new_block (count); |
| topblock = currblock; //set perms here too |
| if (currblock == NULL) { |
| check_mem ("alloc_mem returning NULL", MEMCHECKS); |
| return NULL; |
| } |
| block = currblock; |
| chunk = block->freechunk; //bound to be big enough |
| } |
| } |
| chunkstart = chunk; //start of chunk |
| if (chunk == block->topchunk && chunk + count != block->blockend) |
| block->topchunk += count; //top has moved |
| block->upperspace -= count; //upper part used |
| chunksize = chunk->size; //size of free chunk |
| chunk->size = -count; //mark as used |
| chunk += count; //next free space |
| totalmem -= count; //no of free elements |
| if (chunksize > count) //bigger than exact? |
| //remaining space |
| chunk->size = chunksize - count; |
| else if (chunk == block->blockend) { |
| chunk = block->blockstart; //restart block |
| block->upperspace = block->lowerspace; |
| block->lowerspace = 0; //fix space counts |
| } |
| block->freechunk = chunk; //next free block |
| if (mem_mallocdepth > 0) { |
| set_owner(chunkstart, caller); |
| } |
| else { |
| chunkstart->owner = 0; |
| chunkstart->age = 0; |
| } |
| chunkstart++; //start of block |
| return chunkstart; //pointer to block |
| } |
| |
| |
| /********************************************************************** |
| * MEM_ALLOCATOR::set_owner |
| * |
| * Set the owner and time stamp of the block and check if needed. |
| **********************************************************************/ |
| |
| void MEM_ALLOCATOR::set_owner( //get memory |
| MEMUNION *chunkstart, //chunk to set |
| void *caller //ptr to caller |
| ) { |
| uinT16 callindex; //hash code |
| |
| callindex = hash_caller (caller); |
| chunkstart->owner = callindex; |
| //store evidence |
| chunkstart->age = malloc_serial; |
| malloc_minor_serial++; |
| if (malloc_minor_serial >= malloc_div_ratio) { |
| malloc_minor_serial = 0; |
| malloc_serial++; //count calls |
| if (malloc_serial == 0) { |
| //wrap around |
| reduce_counts(); //fix serial numbers |
| malloc_serial = MAX_INT16 + 1; |
| //all worth double |
| malloc_div_ratio += malloc_div_ratio; |
| } |
| } |
| malloc_auto_count++; |
| if (mem_checkfreq > 0 && malloc_auto_count >= (uinT32) mem_checkfreq) { |
| malloc_auto_count = 0; |
| check_mem ("Auto check", MEMCHECKS); |
| } |
| } |
| |
| |
| /********************************************************************** |
| * MEM_ALLOCATOR::dealloc |
| * |
| * Free a block allocated by alloc (or alloc_p). |
| * It checks that the pointer is legal and maintains counts of the |
| * amount of free memory above and below the current free pointer. |
| **********************************************************************/ |
| |
| void MEM_ALLOCATOR::dealloc( //free memory |
| void *oldchunk, //chunk to free |
| void *caller //ptr to caller |
| ) { |
| MEMUNION *chunk; //current chunk |
| MEMBLOCK *block; //current block |
| |
| if (oldchunk == NULL) |
| FREENULLPTR.error ("free_mem", ABORT, NULL); |
| chunk = (MEMUNION *) oldchunk; |
| block = currblock; //current block |
| if (block == NULL) |
| NOTMALLOCMEM.error ("free_mem", ABORT, NULL); |
| do { |
| block = block->next; |
| } |
| //outside the block |
| while ((chunk - block->blockstart < 0 || block->blockend - chunk <= 0) |
| && block != currblock); |
| |
| if (chunk - block->blockstart < 0 || block->blockend - chunk <= 0) |
| //in no block |
| NOTMALLOCMEM.error ("free_mem", ABORT, NULL); |
| |
| chunk--; //point to size |
| if (chunk->size == 0) |
| //zero size |
| FREEILLEGALPTR.error ("free_mem", ABORT, NULL); |
| else if (chunk->size > 0) |
| //already free |
| FREEFREEDBLOCK.error ("free_mem", ABORT, NULL); |
| chunk->size = -chunk->size; //mark it free |
| if (mem_freedepth > 0 && callers != NULL) { |
| //count calls |
| callers[chunk->owner].count_freeer (caller); |
| } |
| totalmem += chunk->size; //total free memory |
| if (chunk - block->freechunk < 0) |
| //extra below |
| block->lowerspace += chunk->size; |
| else |
| //extra above |
| block->upperspace += chunk->size; |
| } |
| |
| |
| /********************************************************************** |
| * MEM_ALLOCATOR::new_block |
| * |
| * Gets a new big block of memory from malloc for use by alloc_mem. |
| **********************************************************************/ |
| |
| MEMBLOCK *MEM_ALLOCATOR::new_block( //get new big block |
| inT32 minsize //minimum size |
| ) { |
| MEMBLOCK *newblock; //new block |
| |
| if (blockcount >= MAXBLOCKS) { |
| //can't have another |
| NOMOREBLOCKS.error ("mem_new_block", TESSLOG, NULL); |
| return NULL; |
| } |
| if (mem_checkfreq != 0) { |
| tprintf ("\nGetting new block due to request size of %d", |
| minsize * sizeof (MEMUNION)); |
| tprintf (" from %d from %d from %d from %d from %d\n", |
| trace_caller (3), trace_caller (4), trace_caller (5), |
| trace_caller (6), trace_caller (7)); |
| check_mem ("Getting new block", MEMCHECKS); |
| } |
| //get a new one |
| newblock = &memblocks[blockcount++]; |
| while (memsize < minsize) |
| memsize *= 4; //go up in sizes |
| //get a big block |
| newblock->blockstart = (MEMUNION *) |
| malloc (memsize * sizeof (MEMUNION)); |
| if (newblock->blockstart == NULL) { |
| NOMOREMEM.error ("mem_new_block", TESSLOG, NULL); |
| |
| #ifdef __UNIX__ |
| raise(SIGTTOU); //hangup for js |
| #endif |
| return NULL; |
| } |
| //end of block |
| newblock->blockend = newblock->blockstart + memsize; |
| //first free chunk |
| newblock->freechunk = newblock->blockstart; |
| newblock->topchunk = newblock->blockstart; |
| newblock->lowerspace = 0; |
| newblock->upperspace = memsize;//amount available |
| //set pointer |
| newblock->freechunk->size = memsize; |
| newblock->freechunk->owner = 0; |
| newblock->freechunk->age = 0; |
| |
| totalmem += memsize; //total assigned mem |
| |
| if (memsize < maxsize) |
| memsize *= 4; //successively bigger |
| if (currblock == NULL) { |
| newblock->next = newblock; //first block |
| } |
| else { |
| //insert in list |
| newblock->next = currblock->next; |
| currblock->next = newblock; |
| } |
| return newblock; //new block |
| } |
| |
| |
| /********************************************************************** |
| * MEMBLOCK::find_chunk |
| * |
| * Find a chunk within the block which is big enough for the given request |
| **********************************************************************/ |
| |
| MEMUNION *MEMBLOCK::find_chunk( //find free chunk |
| inT32 count //size required |
| ) { |
| MEMUNION *chunk; //current chunk |
| inT32 chunksize; //size of free chunk |
| MEMUNION *chunkstart; //start of free chunk |
| inT32 spaceshift; //shift in lowerspace |
| |
| if (upperspace <= lowerspace) { |
| freechunk = blockstart; //restart chunklist |
| upperspace += lowerspace; |
| lowerspace = 0; //correct space counts |
| } |
| chunk = freechunk; //current free chunk |
| if (chunk->size < count) { //big enough? |
| spaceshift = 0; |
| do { |
| while (chunk->size < 0) { //find free chunk |
| chunk -= chunk->size; //skip forward |
| if (chunk == blockend) { |
| chunk = blockstart; //restart block |
| //gone back to start |
| spaceshift = -lowerspace; |
| } |
| if (chunk == freechunk) |
| return chunk; //gone all round & failed |
| } |
| chunkstart = chunk; //start of chunk |
| chunksize = chunk->size;; |
| chunk += chunk->size; |
| while (chunk != blockend //until end |
| && chunk->size > 0) { //or used |
| chunksize += chunk->size;//coalesce free blocks |
| //gone all round |
| if (chunk == freechunk) { |
| //ensure it is at end |
| freechunk += chunk->size; |
| upperspace -= chunk->size; |
| lowerspace += chunk->size; |
| spaceshift -= chunk->size; |
| } |
| if (chunk == topchunk) //got back to end one |
| topchunk = chunkstart; //end one bigger |
| chunk += chunk->size; //get next block |
| } |
| //new big block |
| chunkstart->size = chunksize; |
| if (chunksize < count) |
| spaceshift += chunksize; //skipping free block |
| if (chunk == blockend) { |
| chunk = blockstart; //back to start |
| if (freechunk == blockend) { |
| freechunk = blockstart;//so is freechunk |
| upperspace += lowerspace; |
| lowerspace = 0; |
| spaceshift = 0; |
| } |
| else |
| //so is shift |
| spaceshift = -lowerspace; |
| } |
| } |
| while (chunksize < count && chunk != freechunk); |
| if (chunksize < count) |
| return chunk; //failed |
| lowerspace += spaceshift; //get space counts right |
| upperspace -= spaceshift; |
| freechunk = chunkstart; |
| return chunkstart; //success |
| } |
| return chunk; //easy |
| } |
| |
| |
| #ifdef __UNIX__ |
| /********************************************************************** |
| * trace_caller |
| * |
| * Return the return address of the caller at a given depth back. |
| * 0 gives the return address of the caller to trace_caller. |
| * S300 ONLY!! |
| **********************************************************************/ |
| //#pragma OPTIMIZE OFF /*force link*/ |
| |
| void *trace_caller( //trace stack |
| inT32 depth //depth to trace |
| ) { |
| #ifdef hp9000s800 |
| |
| unsigned sp, pc, rp; //registers |
| UWREC rec1; //for unwinder |
| UWREC rec2; |
| |
| sp = (unsigned) (&depth + 9); |
| pc = *(int *) (sp - 20); |
| rp = 0; |
| get_pcspace(&rec1, pc); |
| rec1.cur_frsize = 0xc0; |
| rec1.currlo = pc & ~3; |
| rec1.curdp = 0; |
| rec1.toprp = rp; |
| |
| while (depth > 0) { |
| if (U_get_previous_frame (&rec1, &rec2)) |
| return NULL; |
| rec1.currlo = rec2.currlo; |
| rec1.cur_frsize = rec2.cur_frsize; |
| rec1.cursp = rec2.cursp; |
| rec1.currls = rec2.currls; |
| rec1.curdp = rec2.curdp; |
| depth--; |
| } |
| return (void *) rec1.currlo; |
| #else |
| void *a6; //address register |
| |
| a6 = &depth - 2; |
| while (depth > 0) { |
| a6 = *(void **) a6; //follow chain |
| depth--; |
| } |
| return *((void **) a6 + 1); |
| #endif |
| } |
| |
| |
| //#pragma OPTIMIZE ON |
| |
| #else |
| |
| // Fake procedure for non-UNIX |
| void *trace_caller( //trace stack |
| inT32 depth //depth to trace |
| ) { |
| return NULL; |
| } |
| #endif |
| |
| /********************************************************************** |
| * identify_struct_owner |
| * |
| * Get an index into the table of owners of structures. |
| * Implemented very inefficiently, but only a debug tool! |
| **********************************************************************/ |
| |
| inT32 identify_struct_owner( //get table index |
| inT32 struct_count, //cell size |
| const char *name //name of type |
| ) { |
| inT32 index; //index to structure |
| |
| for (index = 0; index < name_counts[struct_count] |
| && strcmp (name, owner_names[struct_count][index]); index++); |
| if (index < MAX_CLASSES) { |
| if (index == name_counts[struct_count]) { |
| name_counts[struct_count]++; |
| owner_names[struct_count][index] = name; |
| owner_counts[struct_count][index] = 0; |
| } |
| } |
| return index; |
| } |
| |
| |
| /********************************************************************** |
| * check_struct |
| * |
| * Check a particular structure size for consistency. |
| **********************************************************************/ |
| |
| void check_struct( //check a structure |
| inT8 level, //print control |
| inT32 count //no of bytes |
| ) { |
| MEMUNION *element; //current element |
| MEMUNION *block; //current block |
| inT32 struct_count; //no of required structs |
| inT32 block_count; //no of structure blocks |
| inT32 free_count; //size of freelist*/ |
| inT32 name_index; //named holder |
| inT32 named_total; //total held by names |
| |
| //no of MEMUNIONS-1 |
| struct_count = (count - 1) / sizeof (MEMUNION); |
| if (struct_count < 0 || struct_count >= MAX_STRUCTS) |
| //request too big |
| MEMTOOBIG.error ("check_struct", ABORT, "%d", (int) count); |
| |
| free_count = 0; //size of freelist |
| //count blocks |
| for (block_count = 0, block = struct_blocks[struct_count]; block != NULL; block = block->ptr, block_count++); |
| if (block_count > 0) { |
| //scan freelist |
| for (element = free_structs[struct_count]; element != NULL; element = element->ptr) |
| free_count++; |
| if (level >= MEMCHECKS) { |
| tprintf ("No of structs of size %d in use=%d,", |
| (int) count, (int) structs_in_use[struct_count]); |
| tprintf (" %d free", free_count); |
| tprintf (" in %d blocks, total space=%d\n", |
| (int) block_count, |
| block_count * STRUCT_BLOCK_SIZE * sizeof (MEMUNION)); |
| for (named_total = 0, name_index = 0; |
| name_index < name_counts[struct_count]; name_index++) { |
| tprintf ("No held by %s=%d\n", |
| owner_names[struct_count][name_index], |
| owner_counts[struct_count][name_index]); |
| named_total += owner_counts[struct_count][name_index]; |
| } |
| tprintf ("Total held by names=%d\n", named_total); |
| } |
| } |
| if (structs_in_use[struct_count] + free_count |
| != block_count * (STRUCT_BLOCK_SIZE / (struct_count + 1) - 1)) |
| BADSTRUCTCOUNT.error ("check_struct", ABORT, "%d+%d=%d", |
| structs_in_use[struct_count], free_count, |
| block_count * (STRUCT_BLOCK_SIZE / |
| (struct_count + 1) - 1)); |
| } |
| |
| |
| /********************************************************************** |
| * check_structs |
| * |
| * Reports statistics on each maintained structure type by calling |
| * free_struct(NULL) on each. Only active structure types are reported. |
| **********************************************************************/ |
| |
| void check_structs( //count in use on structs |
| inT8 level //print control |
| ) { |
| inT8 index; //index to structs |
| |
| for (index = 1; index <= MAX_STRUCTS; index++) |
| //check number allocated |
| check_struct (level, index * sizeof (MEMUNION)); |
| } |
| |
| |
| /********************************************************************** |
| * new_struct_block |
| * |
| * Allocate space for a new block of structures. The space is obtained |
| * from alloc_mem, and a freelist of such blocks is maintained for when |
| * the individual structure types get completely freed. |
| **********************************************************************/ |
| |
| void *new_struct_block() { //allocate memory |
| MEMUNION *element; //current element |
| MEMUNION *returnelement; //return value |
| |
| returnelement = free_block; |
| if (returnelement == NULL) { |
| //need a new block |
| element = |
| (MEMUNION *) alloc_mem_p (STRUCT_BLOCK_SIZE * sizeof (MEMUNION)); |
| if (element == NULL) |
| return NULL; //can't get more |
| returnelement = element; //going to return 1st |
| } |
| else { |
| //new free one |
| free_block = returnelement->ptr; |
| } |
| return returnelement; //free cell |
| } |
| |
| |
| /********************************************************************** |
| * old_struct_block |
| * |
| * Free memory allocated by new_struct_block. The block is returned |
| * to a freelist ready for a new call to new_struct_block. |
| * This saves confusion over freeing "permanent" blocks, yet |
| * allows them to be recycled for different structures. |
| **********************************************************************/ |
| |
| void old_struct_block( //free a structure block |
| MEMUNION *deadblock //block to free |
| ) { |
| if (deadblock != NULL) { |
| deadblock->ptr = free_block; //add to freelist |
| free_block = deadblock; |
| free_struct_blocks++; |
| } |
| if (free_struct_blocks > MAX_FREE_S_BLOCKS) { |
| MEMUNION *next_block; //next in list |
| deadblock = free_block; |
| do { |
| next_block = deadblock->ptr; |
| free_mem(deadblock); //really free it |
| deadblock = next_block; |
| } |
| while (deadblock != NULL); |
| free_struct_blocks = 0; |
| free_block = NULL; |
| } |
| } |
