void* __malloc_internal(size_t size)
{
size_t rounded_size;
size_t shifted_size;
void *address;
/* Round size to a power of two */
rounded_size = MINIMUM_BLOCK_SIZE;
for (shifted_size = (size + MALLOCED_HEADER_SIZE) / MINIMUM_BLOCK_SIZE;
shifted_size; shifted_size >>= 1)
rounded_size <<= 1;
assert(rounded_size >= size + MALLOCED_HEADER_SIZE);
address = find_free_block(rounded_size);
if (address == 0) {
grow_heap(rounded_size);
address = find_free_block(rounded_size);
if (address == 0)
return 0;
}
memset(address, ALLOC_FILL, rounded_size - MALLOCED_HEADER_SIZE);
allocated_blocks++;
total_allocations++;
total_allocated += rounded_size;
return address;
}
void* emma_malloc(size_t size)
{
memory_page* list;
int base;
size_t blksize;
memory_block *block;
blksize = emma_nextp2(size);
// get matching list
base = emma_log2(blksize);
if(memory_table_len < (base + 1))
{
init_memory_table(blksize);
}
// initialise first page of memory if not yet done
if(memory_table[base] == 0)
{
memory_table[base] = init_memory_page(blksize);
}
list = memory_table[base];
// get a free block of the according size
block = find_free_block(list); // TODO not working...
// allocate a new page of memory if necessary
if(block == 0)
{
memory_page *pNewPage, *currPage;
pNewPage = init_memory_page(blksize);
// add new page to the memory list
currPage = list;
while(currPage->next != 0)
{
currPage = currPage->next;
}
currPage->next = pNewPage;
block = find_free_block(pNewPage); // get a free block on the new page
}
// safeguard memory
memcpy(block->sgPre, EMMA_SG, EMMA_SG_LEN);
memcpy(block->sgPost, EMMA_SG, EMMA_SG_LEN);
return block->data;
}
char *
malloc(size_t size) {
struct malloc_chunk *block;
if (size <= 0) {
return NULL;
}
if (!heap_start) { // First call.
block = request_space(NULL, size);
if (!block) {
return NULL;
}
heap_start = (char*) block;
} else {
struct malloc_chunk *last = (struct malloc_chunk*) heap_start;
block = find_free_block(&last, size);
if (!block) { // Failed to find free block.
block = request_space(last, size);
if (!block) {
return NULL;
}
} else {
// Found a block we can re-use
/*
if ((block->size - size) > (31+MALLOC_CHUNK_SIZE)) {
// if the block we are re-using is considerably larger (32 bytes)
// than what we request, then split it.
int old_size = block->size;
block->size = size;
// save next ptr
struct malloc_chunk *next = (struct malloc_chunk*) block->fd;
char* p = (char*) block;
p = p + (MALLOC_CHUNK_SIZE + size);
block->fd = (struct malloc_chunk*) p;
// point to next free byte
//(char*) block->fd = (char*) block + size + MALLOC_CHUNK_SIZE;
// create a new block header for the remainder of the block
struct malloc_chunk *split = (struct malloc_chunk*) block->fd;
split->size = old_size - MALLOC_CHUNK_SIZE - size;
split->is_free = 1;
split->fd = next;
}
*/
block->is_free = 0;
}
}
return(block+1);
}
void *myallocate_self(int size)
{
struct block_meta *block;
struct block_meta *last = global_base;
if (!global_base)
{ // First call.
block = request_space(NULL, size);
if (!block)
{
return NULL;
}
global_base = block;
}
else {
block = find_free_block(&last, size);
if (!block)
{ // Failed to find free block.
block = request_space(last, size);
if (!block)
{
return NULL;
}
}
else
{ // Found free block
// TODO: consider splitting block here.
block->free = 0;
}
}
return block;
}
int get_free_block(jfs_t *jfs)
{
int groups, i;
if (jfs->d_img->size % (BLOCKSIZE * BLOCKS_PER_GROUP) == 0) {
groups = jfs->d_img->size / (BLOCKSIZE * BLOCKS_PER_GROUP);
} else {
groups = 1 + jfs->d_img->size / (BLOCKSIZE * BLOCKS_PER_GROUP);
}
for (i = 0; i < groups; i++) {
struct blockgroup *grp;
char block[BLOCKSIZE];
int freeblock;
/* read the blockgroup header */
jfs_read_block(jfs, block, i * BLOCKS_PER_GROUP);
grp = (struct blockgroup *)block;
freeblock = -1;
freeblock = find_free_block(grp->block_bitmap);
if (freeblock >= 0) {
set_block_used(grp->block_bitmap, freeblock);
jfs_write_block(jfs, block, i * BLOCKS_PER_GROUP);
/* if there's a free block in this group, then return it */
freeblock += i * BLOCKS_PER_GROUP;
/* printf("allocating free block: %d\n", freeblock);*/
return freeblock;
}
}
return -1;
}
/*
* mm_realloc - Implemented fairly simply by finding a free block (or expanding the heap), copying the data, and freeing the original block
*/
void *mm_realloc(void *ptr, size_t size)
{
int totalSizeNeeded = ALIGN(size + OVERHEAD);
listBlock *oldBlock = ptr - OFFSET;
listBlock *newBlock = find_free_block(totalSizeNeeded);
int copySize = (oldBlock->header & ~0x1) - OFFSET;
if (totalSizeNeeded < copySize) {
copySize = totalSizeNeeded;
}
if (newBlock == NULL) { // no free block found
newBlock = (listBlock *)mem_sbrk(totalSizeNeeded);
if ((long)newBlock == -1) {
return NULL;
}
else {
newBlock->header = totalSizeNeeded | 0x1;
int *footer = (int *)(((char *)newBlock) + totalSizeNeeded - WORD_SIZE);
*footer = totalSizeNeeded | 0x1;
}
}
else { // if a free block was found
if (newBlock->header - totalSizeNeeded < OVERHEAD) { // not enough room left over for overhead of a free block
newBlock->header = newBlock->header | 0x1; // allocate the whole block
newBlock->prev->next = newBlock->next; // remove from free list
newBlock->next->prev = newBlock->prev;
}
else {
int oldBlockSize = newBlock->header; // store the found block's size
newBlock->header = totalSizeNeeded | 0x1;
int *footer = (int *)(((char *)newBlock) + totalSizeNeeded - WORD_SIZE);
*footer = totalSizeNeeded | 0x1;
listBlock *splitBlock = (listBlock *)(((char *)newBlock) + totalSizeNeeded);
splitBlock->header = oldBlockSize - totalSizeNeeded;
footer = (int *)(((char *)splitBlock) + splitBlock->header - WORD_SIZE);
*footer = oldBlockSize - totalSizeNeeded;
splitBlock->prev = newBlock->prev; // insert splitBlock into the free list
splitBlock->next = newBlock->next;
newBlock->prev->next = splitBlock; // remove newBlock from the free list and redirect to splitBlock
newBlock->next->prev = splitBlock;
}
}
if (newBlock == NULL) {
return NULL;
}
newBlock = (listBlock *)((char *)newBlock + OFFSET);
memcpy(newBlock, ptr, copySize);
mm_free(ptr);
return newBlock;
}
void *getmem_debug(size_t n, char *file, int line)
{
void *x = getmem_raw(n + ALIGNSHIFT);
long i = find_free_block();
*(long *)x = i;
mem[i].block = x;
mem[i].serial = current_serial ++;
mem[i].file = file;
mem[i].line = line;
return (void *)((unsigned char *)x + ALIGNSHIFT);
}
static int find_writeable_block(struct partition *part, u_long *old_sector)
{
int rc, block;
size_t retlen;
block = find_free_block(part);
if (block == -1) {
if (!part->is_reclaiming) {
rc = reclaim_block(part, old_sector);
if (rc)
goto err;
block = find_free_block(part);
}
if (block == -1) {
rc = -ENOSPC;
goto err;
}
}
rc = part->mbd.mtd->read(part->mbd.mtd, part->blocks[block].offset,
part->header_size, &retlen, (u_char*)part->header_cache);
if (!rc && retlen != part->header_size)
rc = -EIO;
if (rc) {
printk(KERN_NOTICE PREFIX "'%s': unable to read header at "
"0x%lx\n", part->mbd.mtd->name,
part->blocks[block].offset);
goto err;
}
part->current_block = block;
err:
return rc;
}
/* Allocate a block of memory from the mark and sweep GC heap */
heap_block *heap::heap_allot(cell size, cell type)
{
size = (size + block_size_increment - 1) & ~(block_size_increment - 1);
free_heap_block *block = find_free_block(size);
if(block)
{
block = split_free_block(block,size);
block->set_type(type);
block->set_marked_p(false);
return block;
}
else
return NULL;
}
/* Allocate a block of memory from the mark and sweep GC heap */
heap_block *heap::heap_allot(cell size)
{
size = (size + block_size_increment - 1) & ~(block_size_increment - 1);
free_heap_block *block = find_free_block(size);
if(block)
{
block = split_free_block(block,size);
block->status = B_ALLOCATED;
return block;
}
else
return NULL;
}
int
blockdevice_writeblock(BLOCKDEVICEP dev, void *block, int offset, int size, int blocknum, int waitforcomplete)
{
int i ;
int rc ;
if (! dev) {
/*printf("!dev\n") ;*/
return -1 ;
}
if ((size < 0) || (offset < 0)) {
/*printf("size < 1 %d, offset < 0 %d\n", size,offset) ;*/
return -1 ;
}
if ( size > dev->blocksize ) {
/*printf("size %d > dev->blocksize %d\n", size, dev->blocksize) ;*/
return -1 ;
}
if (offset > size) {
/*printf("offset %d > size %d\n", size, dev->blocksize) ;*/
return -1 ;
}
i = find_free_block(dev->bd->datablocks, dev->numblocks) ;
/*
** Yay! We found a block, stuff data into it!
*/
dev->bd->datablocks[i].datalength = size ;
dev->bd->datablocks[i].blocknum = blocknum ;
dev->bd->datablocks[i].offset = offset ;
memcpy(dev->bd->datablocks[i].data, block, size) ;
/*
** Signal dirty block.
*/
rc = semaphore_increment(dev->dirtysem) ;
if (waitforcomplete) {
rc = semaphore_decrement(dev->sem) ;
}
return size ;
}
int ia_move(t_princ *lemip)
{
t_pos direction;
direction.x = -1;
direction.y = -1;
ia_scan_map(lemip, &(lemip->player), &direction);
if (direction.x == -1 || lemip->map[direction.y *
MAP_LEN + direction.x] != 0)
find_free_block(lemip, &direction);
if (direction.x != -1)
{
lemip->map[lemip->player.ia.y * MAP_LEN + lemip->player.ia.x] = 0;
lemip->player.ia.x = direction.x;
lemip->player.ia.y = direction.y;
lemip->map[direction.y * MAP_LEN + direction.x] = lemip->player.team;
}
return (0);
}
void *malloc(size_t size){
sum_allocs++;
sum_alloc_size += size;
num_allocated++;
block_t current, last;
size = align_pointer(size);
if (base) {
/* First find a block */
last = base;
current = find_free_block(&last, size);
if (current) {
//there is a fitting free block
if (BLOCK_SIZE_MIN <= current->size - size){
// we can split the block
split_block(current, size);
}
current->free=0;
} else {
//there are no fitting blocks
current = new_block(last, size);
if (!current){ // error
perror("error at !current");
return NULL;
}
}
} else {
//first malloc (base == NULL)
current = new_block(NULL, size);
if (!current){
perror("error at !current");
return(NULL);
}
base = current;
}
return current->raw;
}
/*
* malloc
*/
void *malloc (size_t size) {
void* p;
int index;
if(heap_start == 0)
mm_init();
checkheap(1); // Let's make sure the heap is ok!
if(size == 0) return NULL;
size += 8 - size%8;
size += (HEADER_SIZE + FOOTER_SIZE);
if(size > MAX_SIZE) return NULL;
index = get_free_list_index(size);
p = find_free_block(index, size);
if(p == NULL) return NULL;
p = block_mem(p);
checkheap(1);
return p;
}
/*
* mm_malloc - Checks for an available free block of at least the required size (taking overhead and alignment into account).
* If no suitable free block is found, the heap is expanded by 2 x size, split, and coalesced if possible. If one is found, it's
* split if possible, otherwise the whole block is used.
*/
void *mm_malloc(size_t size)
{
unsigned int totalSizeNeeded = ALIGN(size + OVERHEAD);
listBlock *newBlock = find_free_block(totalSizeNeeded);
int *footer;
if (newBlock == NULL) { // no free block large enough
newBlock = (listBlock *)mem_sbrk(totalSizeNeeded * 2);
if ((long)newBlock == -1) {
return NULL;
}
else {
newBlock->header = totalSizeNeeded; // set up free block at front
footer = (int *)(((char *)newBlock) + totalSizeNeeded - WORD_SIZE);
*footer = totalSizeNeeded;
listBlock *firstFree = (listBlock *)mem_heap_lo(); // insert into free list
newBlock->next = firstFree->next;
newBlock->prev = firstFree;
firstFree->next = newBlock;
newBlock->next->prev = newBlock;
listBlock *allocate = (listBlock *)(((char *)newBlock) + totalSizeNeeded); // create a new allocated block after the free block
allocate->header = totalSizeNeeded | 0x1;
footer = (int *)(((char *)allocate) + totalSizeNeeded - WORD_SIZE);
*footer = totalSizeNeeded | 0x1;
/* try coalesing the new leading free portion with the block in front */
int *lowerFooter = (int *)(((char *)newBlock) - WORD_SIZE);
listBlock *lowerBlock = (listBlock *)(((char *)newBlock) - (*lowerFooter & ~0x1));
if ((lowerBlock->header & 0x1) == 0) { // if previous block is free
if (lowerBlock != (listBlock *)mem_heap_lo()) { // coalesce if it isn't the dummy starting block
lowerBlock->header = lowerBlock->header + newBlock->header;
footer = (int *)(((char *)lowerBlock) + lowerBlock->header - WORD_SIZE);
*footer = lowerBlock->header;
newBlock->next->prev = newBlock->prev; // remove block being absorbed from free list
newBlock->prev->next = newBlock->next;
}
}
return (char *)allocate + OFFSET;
}
}
/* If a free block was found, split if possible and relink the free list appropriately */
else {
if (newBlock->header - totalSizeNeeded < OVERHEAD) { // not enough room left over to accomodate overhead required for a free block
footer = (int *)(((char *)newBlock) + newBlock->header - WORD_SIZE); // set pointer to the footer
newBlock->header = newBlock->header | 0x1; // then just allocate the entire block
*footer = newBlock->header;
newBlock->prev->next = newBlock->next; // splice it out from the free list
newBlock->next->prev = newBlock->prev;
}
else { // there is room left over to split the blocks
int oldBlockSize = newBlock->header; // store the original block size
newBlock->header = totalSizeNeeded | 0x1; // allocate a block of just the necessary size
footer = (int *)(((char *)newBlock) + totalSizeNeeded - WORD_SIZE); // set pointer to footer
*footer = totalSizeNeeded | 0x1; // set footer to size and allocated
listBlock *splitBlock = (listBlock *)(((char *)newBlock) + totalSizeNeeded); // place a pointer immediately following the newly allocated block
splitBlock->header = oldBlockSize - totalSizeNeeded; // set the size of the new free block
footer = (int *)(((char *)splitBlock) + splitBlock->header - WORD_SIZE); // set pointer to footer
*footer = oldBlockSize - totalSizeNeeded;
splitBlock->prev = newBlock->prev; // insert splitBlock into the free list
splitBlock->next = newBlock->next;
newBlock->prev->next = splitBlock; // remove newBlock from the free list and redirect to splitBlock
newBlock->next->prev = splitBlock;
}
}
return (char *)newBlock + OFFSET;
}
/* returns: a block of allocated memory of the specified size */
void* marksweep_malloc(size_t size_in_bytes)
{
#ifdef WITH_PRECISE_GC_STATISTICS
static jint time = 0;
#endif
static size_t bytes_allocated = 0;
size_t aligned_size_in_bytes = 0;
void *result = NULL;
aligned_size_in_bytes = align(size_in_bytes + BLOCK_HEADER_SIZE);
ENTER_MARKSWEEP_GC();
#ifdef GC_EVERY_TIME
marksweep_collect();
#endif
result = find_free_block(aligned_size_in_bytes,
&(heap.free_list),
heap.small_blocks);
if (result != NULL)
{
// get past block header
result = ((struct block *)result)->object;
}
else
{
// no free blocks, allocate or expand heap
if (collection_makes_sense(bytes_allocated))
{
setup_for_threaded_GC();
marksweep_collect();
bytes_allocated = 0;
cleanup_after_threaded_GC();
}
// see if we have the necessary memory,
// either with or without collection
result = allocate_in_marksweep_heap(aligned_size_in_bytes, &heap);
// if we didn't collect already and we
// ran out of memory, run a collection
if (result == NULL && bytes_allocated != 0) {
setup_for_threaded_GC();
marksweep_collect();
bytes_allocated = 0;
cleanup_after_threaded_GC();
}
}
// if no memory at this point, just fail
assert(result != NULL);
#ifdef WITH_PRECISE_GC_STATISTICS
{
struct block *bl = result - BLOCK_HEADER_SIZE;
bl->time = time++;
}
#endif
bytes_allocated += aligned_size_in_bytes;
EXIT_MARKSWEEP_GC();
return result;
}