/**********************************************************************
* File: memry.c (Formerly memory.c)
* Description: Memory allocation with builtin safety checks.
* Author: Ray Smith
* Created: Wed Jan 22 09:43:33 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"
#include <stdlib.h>
#ifdef __UNIX__
#include <assert.h>
#endif
#include "stderr.h"
#include "tprintf.h"
#include "memblk.h"
#include "memry.h"
//#define COUNTING_CLASS_STRUCTURES
/**********************************************************************
* new
*
* Replace global new to get at memory leaks etc.
**********************************************************************/
/*
void* operator new( //allocate memory
size_t size //amount to allocate
)
{
if (size==0)
{
err.log(RESULT_LOGICAL_ERROR,E_LOC,ERR_PRIMITIVES,
ERR_SCROLLING,ERR_CONTINUE,ERR_ERROR,
"Zero requested of new");
size=1;
}
return alloc_big_mem(size);
}
void operator delete( //free memory
void* addr //mem to free
)
{
free_big_mem(addr);
}*/
/**********************************************************************
* check_mem
*
* Check consistency of all memory controlled by alloc_mem.
**********************************************************************/
DLLSYM void check_mem( //check consistency
const char *string, //context message
inT8 level //level of check
) {
big_mem.check (string, level);
main_mem.check (string, level);
check_structs(level);
}
/**********************************************************************
* alloc_string
*
* Allocate space for a string. The space can only be used for chars as
* it is not aligned. Allocation is guaranteed to be fast and not cause
* fragmentation for small strings (upto 10*worst alignment). Calls for
* larger strings will be satisfied with alloc_mem.
* Use free_string to free the space from alloc_string.
**********************************************************************/
DLLSYM char *alloc_string( //allocate string
inT32 count //no of chars required
) {
#ifdef RAYS_MALLOC
char *string; //allocated string
if (count < 1 || count > MAX_CHUNK) {
tprintf ("Invalid size %d requested of alloc_string", count);
return NULL;
}
count++; //add size byte
if (count <= MAX_STRUCTS * sizeof (MEMUNION)) {
string = (char *) alloc_struct (count, "alloc_string");
//get a fast structure
if (string == NULL) {
tprintf ("No memory for alloc_string");
return NULL;
}
string[0] = (inT8) count; //save its length
}
else {
//get a big block
string = (char *) alloc_mem (count);
if (string == NULL) {
tprintf ("No memory for alloc_string");
return NULL;
}
string[0] = 0; //mark its id
}
return &string[1]; //string for user
#else
// Round up the amount allocated to a multiple of 4
return static_cast<char*>(malloc((count + 3) & ~3));
#endif
}
/**********************************************************************
* free_string
*
* Free a string allocated by alloc_string.
**********************************************************************/
DLLSYM void free_string( //free a string
char *string //string to free
) {
#ifdef RAYS_MALLOC
if (((ptrdiff_t) string & 3) == 1) { //one over word
string--; //get id marker
if (*string == 0) {
free_mem(string); //generally free it
return;
}
else if (*string <= MAX_STRUCTS * sizeof (MEMUNION)) {
//free structure
free_struct (string, *string, "alloc_string");
return;
}
}
tprintf ("Non-string given to free_string");
#else
free(string);
#endif
}
/**********************************************************************
* alloc_struct
*
* Allocate space for a structure. This function is designed to be
* fast and fragmentation free for arbitrary combinations of small
* objects. (Upto 40 bytes in length.)
* It can be used for any size of object up to 512K, but you must use
* free_struct to release the memory it gives. alloc_mem is better
* for arbitrary data blocks of large size (>40 bytes.)
* alloc_struct always aborts if the allocation fails.
**********************************************************************/
DLLSYM void *
alloc_struct ( //allocate memory
inT32 count, //no of chars required
#if defined COUNTING_CLASS_STRUCTURES
const char *name //name of type
#else
const char * //name of type
#endif
) {
#ifdef RAYS_MALLOC
MEMUNION *element; //current element
MEMUNION *returnelement; //return value
inT32 struct_count; //no of required structs
inT32 blocksize; //no of structs in block
inT32 index; //index to structure
if (count < 1 || count > MAX_CHUNK) {
tprintf ("Invalid size %d requested of alloc_struct", count);
return NULL;
}
// tprintf("Allocating structure of size %d\n",count);
//no of MEMUNIONS-1
struct_count = (count - 1) / sizeof (MEMUNION);
if (struct_count < MAX_STRUCTS) {
//can do fixed sizes
#ifdef COUNTING_CLASS_STRUCTURES
if (name != NULL) {
index = identify_struct_owner (struct_count, name);
if (index < MAX_CLASSES)
owner_counts[struct_count][index]++;
}
#endif
//head of freelist
returnelement = free_structs[struct_count];
if (returnelement == NULL) {
//need a new block
//get one
element = (MEMUNION *) new_struct_block ();
if (element == NULL) {
tprintf ("No memory to satisfy request for %d", (int) count);
return NULL;
}
//add to block list
element->ptr = struct_blocks[struct_count];
struct_blocks[struct_count] = element;
blocks_in_use[struct_count]++;
element++; //free cell
returnelement = element; //going to return 1st
blocksize = STRUCT_BLOCK_SIZE / (struct_count + 1) - 1;
for (index = 1; index < blocksize; index++) {
//make links
element->ptr = element + struct_count + 1;
element += struct_count + 1;
}
element->ptr = NULL; //end of freelist
}
//new free one
free_structs[struct_count] = returnelement->ptr;
//count number issued
structs_in_use[struct_count]++;
}
else {
//just get some
returnelement = (MEMUNION *) alloc_mem (count);
if (returnelement == NULL) {
tprintf ("No memory to satisfy request for %d", (int) count);
return NULL;
}
}
return returnelement; //free cell
#else
return malloc(count);
#endif
}
/**********************************************************************
* free_struct
*
* Free memory allocated by alloc_struct. The size must be supplied.
**********************************************************************/
DLLSYM void
free_struct ( //free a structure
void *deadstruct, //structure to free
inT32 count, //no of bytes
#if defined COUNTING_CLASS_STRUCTURES
const char *name //name of type
#else
const char * //name of type
#endif
) {
#ifdef RAYS_MALLOC
MEMUNION *end_element; //current element
MEMUNION *element; //current element
MEMUNION *prev_element; //previous element
MEMUNION *prev_block; //previous element
MEMUNION *nextblock; //next block in list
MEMUNION *block; //next block in list
inT32 struct_count; //no of required structs
inT32 index; //to structure counts
if (count < 1 || count > MAX_CHUNK) {
tprintf ("Invalid size %d requested of free_struct", count);
return;
}
// tprintf("Freeing structure of size %d\n",count);
//no of MEMUNIONS-1
struct_count = (count - 1) / sizeof (MEMUNION);
if (deadstruct == NULL) {
//not really legal
check_struct(MEMCHECKS, count);
}
else {
if (struct_count < MAX_STRUCTS) {
//can do fixed sizes
#ifdef COUNTING_CLASS_STRUCTURES
if (name != NULL) {
index = identify_struct_owner (struct_count, name);
if (index < MAX_CLASSES) {
owner_counts[struct_count][index]--;
ASSERT_HOST (owner_counts[struct_count][index] >= 0);
}
}
#endif
element = (MEMUNION *) deadstruct;
//add to freelist
element->ptr = free_structs[struct_count];
free_structs[struct_count] = element;
//one less in use
structs_in_use[struct_count]--;
if (structs_in_use[struct_count] == 0) {
index = 0;
for (element = struct_blocks[struct_count];
element != NULL; element = nextblock) {
//traverse and destroy
nextblock = element->ptr;
//free all the blocks
old_struct_block(element);
index++;
}
//none left any more
struct_blocks[struct_count] = NULL;
//no free structs
free_structs[struct_count] = NULL;
blocks_in_use[struct_count] = 0;
}
else if (structs_in_use[struct_count] < 0) {
tprintf ("Negative number of structs of size %d in use",
(int) count);
}
else if (structs_in_use[struct_count] < blocks_in_use[struct_count]) {
prev_block = NULL;
for (block = struct_blocks[struct_count];
block != NULL; block = nextblock) {
nextblock = block;
index = STRUCT_BLOCK_SIZE / (struct_count + 1) - 1;
end_element = block + STRUCT_BLOCK_SIZE;
for (element = free_structs[struct_count];
element != NULL; element = element->ptr) {
if (element > nextblock && element < end_element) {
index--;
if (index == 0)
break;
}
}
if (index == 0) {
index = STRUCT_BLOCK_SIZE / (struct_count + 1) - 1;
for (element =
free_structs[struct_count], prev_element = NULL;
element != NULL; element = element->ptr) {
if (element > nextblock && element < end_element) {
index--;
if (prev_element != NULL)
prev_element->ptr = element->ptr;
else
free_structs[struct_count] = element->ptr;
if (index == 0)
break;
}
else
prev_element = element;
}
if (prev_block != NULL)
prev_block->ptr = block->ptr;
else
struct_blocks[struct_count] = block->ptr;
nextblock = block->ptr;
blocks_in_use[struct_count]--;
//free all the blocks
old_struct_block(block);
}
else {
prev_block = block;
//traverse and destroy
nextblock = block->ptr;
}
}
}
}
else
free_mem(deadstruct); //free directly
}
#else
free(deadstruct);
#endif
}
/**********************************************************************
* alloc_mem_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.
**********************************************************************/
//#ifdef __UNIX__
//#pragma OPT_LEVEL 0
//#endif
DLLSYM void *alloc_mem_p( //allocate permanent space
inT32 count //block size to allocate
) {
#ifdef RAYS_MALLOC
#ifdef TESTING_BIGSTUFF
if (main_mem.biggestblock == 0)
main_mem.init (alloc_big_mem, free_big_mem,
FIRSTSIZE, LASTSIZE, MAX_CHUNK);
#else
if (main_mem.biggestblock == 0)
main_mem.init ((void *(*)(inT32)) malloc, free,
FIRSTSIZE, LASTSIZE, MAX_CHUNK);
#endif
if (mem_mallocdepth > 0)
return main_mem.alloc_p (count, trace_caller (mem_mallocdepth));
else
return main_mem.alloc_p (count, NULL);
#else
return malloc ((size_t) count);
#endif
}
/**********************************************************************
* alloc_mem
*
* Return a pointer to a buffer of count bytes aligned for any type.
**********************************************************************/
DLLSYM void *alloc_mem( //get some memory
inT32 count //no of bytes to get
) {
#ifdef RAYS_MALLOC
#ifdef TESTING_BIGSTUFF
if (main_mem.biggestblock == 0)
main_mem.init (alloc_big_mem, free_big_mem,
FIRSTSIZE, LASTSIZE, MAX_CHUNK);
#else
if (main_mem.biggestblock == 0)
main_mem.init ((void *(*)(inT32)) malloc, free,
FIRSTSIZE, LASTSIZE, MAX_CHUNK);
#endif
if (mem_mallocdepth > 0)
return main_mem.alloc (count, trace_caller (mem_mallocdepth));
else
return main_mem.alloc (count, NULL);
#else
return malloc ((size_t) count);
#endif
}
/**********************************************************************
* alloc_big_mem
*
* Return a pointer to a buffer of count bytes aligned for any type.
**********************************************************************/
DLLSYM void *alloc_big_mem( //get some memory
inT32 count //no of bytes to get
) {
#ifdef TESTING_BIGSTUFF
if (big_mem.biggestblock == 0)
big_mem.init ((void *(*)(inT32)) malloc, free,
BIGSIZE, BIGSIZE, MAX_BIGCHUNK);
if (mem_mallocdepth > 0)
return big_mem.alloc (count, trace_caller (mem_mallocdepth));
else
return big_mem.alloc (count, NULL);
#else
return malloc ((size_t) count);
#endif
}
/**********************************************************************
* alloc_big_zeros
*
* Return a pointer to a buffer of count bytes aligned for any type.
**********************************************************************/
DLLSYM void *alloc_big_zeros( //get some memory
inT32 count //no of bytes to get
) {
#ifdef TESTING_BIGSTUFF
if (big_mem.biggestblock == 0)
big_mem.init ((void *(*)(inT32)) malloc, free,
BIGSIZE, BIGSIZE, MAX_BIGCHUNK);
void *buf; //return value
if (mem_mallocdepth > 0)
buf = big_mem.alloc (count, trace_caller (mem_mallocdepth));
else
buf = big_mem.alloc (count, NULL);
memset (buf, 0, count);
return buf;
#else
return calloc ((size_t) count, 1);
#endif
}
/**********************************************************************
* free_mem
*
* Free a block allocated by alloc_mem (or alloc_mem_p).
* It checks that the pointer is legal and maintains counts of the
* amount of free memory above and below the current free pointer.
**********************************************************************/
DLLSYM void free_mem( //free mem from alloc_mem
void *oldchunk //chunk to free
) {
#ifdef RAYS_MALLOC
if (mem_freedepth > 0 && main_mem.callers != NULL)
main_mem.dealloc (oldchunk, trace_caller (mem_freedepth));
else
main_mem.dealloc (oldchunk, NULL);
#else
free(oldchunk);
#endif
}
/**********************************************************************
* free_big_mem
*
* Free a block allocated by alloc_big_mem.
* It checks that the pointer is legal and maintains counts of the
* amount of free memory above and below the current free pointer.
**********************************************************************/
DLLSYM void free_big_mem( //free mem from alloc_mem
void *oldchunk //chunk to free
) {
#ifdef TESTING_BIGSTUFF
if (mem_freedepth > 0 && main_mem.callers != NULL)
big_mem.dealloc (oldchunk, trace_caller (mem_freedepth));
else
big_mem.dealloc (oldchunk, NULL);
#else
free(oldchunk);
#endif
}