bmalloc.c

Go to the documentation of this file.

/* BeeOS v0.1. Created: 2003/08/10 Modified: 2004/03/03
 * Copyright (C) 2004 Paul Harvey - ROMA, Australia.
 * csirac@users.sourceforge.net
 */

/*   This program is free software; you can redistribute it and/or modify
 *   it under the terms of the GNU General Public License as published by
 *   the Free Software Foundation; either version 2 of the License, or
 *   (at your option) any later version.
 * 
 *   This program is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU General Public License for more details.
 * 
 *   You should have received a copy of the GNU General Public License
 *   along with this program; if not, write to the Free Software
 *   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
#include "../include/beeos.h"
#include "../include/bbit.h"
#define IN_BMEM                 /* "internal" globals, for splint */
#include "../include/bmalloc.h"
#include "../include/bstring.h" /* for bmemset(). */
#include "../include/arch/param.h"  /* for SRAM_SIZE */
/* TEMPRY */
#include <stdarg.h>
#include "../include/bprintf.h"

#ifdef HOSTED_BUILD
#include <malloc.h>
#endif
#ifdef BMEM_DEBUG
/* #include <stdio.h> */
#endif

/* GLOBALS OF EVIL */
#ifndef HOSTED_BUILD
    /*@-isoreserved@*/
    extern char _end;   /* set by linker: start of "free" data segment */
    /*@=isoreserved@*/
#endif

static char /*@exposed@*/ /*@null@*/ *bheap = NULL;
static uchar bheap_bitmap[SRAM_NUMBLOCKS/8 + 1];    
static bool lk_bmalloc; 
static bool lk_bfree;       
/* END GLOBALS OF EVIL */

/*@external@*/ 
void bmallocinit(void) 
    /*@globals bheap_bitmap, undef bheap@*/
    /*@modifies bheap@*/
{   
#ifndef HOSTED_BUILD
    bheap = (char *) &_end; 
#else
    bheap = malloc((size_t) SRAM_NUMBLOCKS*SRAM_BLOCKSIZE);
#endif
    /* About the line below.... not sure _end is supposed to be modified. */
    /*_end += (SRAM_NUMBLOCKS*SRAM_BLOCKSIZE);*/ /* update _end to after bheap*/
    bmemset(bheap, '\0', (ushort)SRAM_NUMBLOCKS*SRAM_BLOCKSIZE);
    bmemset((char *)bheap_bitmap, '\0', (ushort)SRAM_NUMBLOCKS/8);
    lk_bfree = false;
    lk_bmalloc = false;
#ifdef BMEM_DEBUG
    /*@-nullptrarith@*/
    bprintf(20, "bminit: bheap %x, frm %p to %p.\r\n", 
        (sshort) SRAM_NUMBLOCKS*SRAM_BLOCKSIZE, (sshort) bheap, 
        (sshort) bheap + SRAM_NUMBLOCKS*SRAM_BLOCKSIZE);
    /*@=nullptrarith@*/
#endif
    
    return;
}

/*@-redef@*/ /*@-exportlocal@*/
/*@external@*/
void bfree(char /*@null@*/ *addr)
/*@=redef@*/ /*@-exportlocal@*/
{   
    uchar i = (uchar) SRAM_ADDR2BLOCK(addr);
/*@-nullptrarith@*/
    uchar end_block = 0;
    
#ifdef BMEM_DEBUG
    bprintf(20, "bfr: Free %i blks @%p.\r\n", (sshort)ALLOC_NUMBLOCKS(addr), 
        (sshort) addr);
#endif
/*@=nullptrarith@*/
    while (lk_bfree);   /* Wait for other thread's bfree() call to finish */
    lk_bfree = true;
    end_block = (uchar) i + (uchar) ALLOC_NUMBLOCKS(addr);
    for (; i < end_block; i++) SRAM_BITCLR(i);
    lk_bfree = false;
    
    return;
}

/*@-redef@*/
/*@null@*/ /*@exposed@*/ /*@external@*/
char *bmalloc(ushort size, char /*@exposed@*/ /*@null@*/ *pExist)
    /*@globals bheap, bheap_bitmap@*/
    /*@modifies *bheap, *pExist@*/
/*@=redef@*/
{   
    char *pMem = NULL;
    bool tagged_a_block = false;
    bool blockused = false;
    /*NB:div. truncated so +1 */
    uchar reqrd_blocks = (uchar)(size + 1)/(uchar)SRAM_BLOCKSIZE;
    uchar i = 0, tagged_block = 0;
    uchar exist_block, exist_blocks;

    while (lk_bmalloc); /* Wait for other thread's bmalloc() call to finish. */
    lk_bmalloc = true;
    /* NB: reqrd_blocks++ if alloc. accounting byte won't fit with req. size */
/*@-type@*/ /*(char) i++ non-numeric?*/
    if (((size + 1) % SRAM_BLOCKSIZE) != 0) reqrd_blocks++;
/*@=type@*/
#ifdef BREALLOC
    /* Deal with existing alloc'd address (IE. resize alloc. request) */
    if (NULL != pExist) {
        exist_blocks = ALLOC_NUMBLOCKS(pExist);
        exist_block = (uchar)SRAM_ADDR2BLOCK(pExist);
        if (exist_blocks == reqrd_blocks) return pExist;
        else if (exist_blocks < reqrd_blocks) {
            /* This code allows bmalloc() to reduce a previous alloc */
            i = (exist_blocks - reqrd_blocks);
            /*@-nullptrarith@*/
            pMem = (char *) SRAM_BLOCK2ADDR((int)exist_block + (int)i);
            /*@=nullptrarith@*/
            *((uchar *)pMem) = i;
            bfree(pMem + 1);
            ALLOC_NUMBLOCKS(pExist) = reqrd_blocks;
            return pExist;
        } else { /* This code allows bmalloc() to increase a previous alloc. */
            /* Start free block scan just after currently alloc'd blocks */
            i = exist_block + exist_blocks;
            tagged_block = exist_block;
            tagged_a_block = true;
        }
#   ifdef BMEM_DEBUG
        bprintf(20, "bmal: REA: was %i, need %i.\r\n", (sshort)exist_blocks, 
            (sshort)reqrd_blocks);
#   endif
    }
#endif
    /* Loop until enough contiguous blocks are found to satisfy size required */
    while (i < (uchar)SRAM_NUMBLOCKS) {
        blockused = SRAM_BITCHECK(i);   /* Consult bitmap: check block i used */
        if (tagged_a_block) { /*Below, LHS: +1:include zero diff*/
            if ((i - tagged_block + 1) >= (ushort) reqrd_blocks) {
                /* finished searching, enough blocks found*/
                for (i = tagged_block; i < ((uchar) reqrd_blocks + tagged_block); i++)
                    SRAM_BITSET(i);     /* Mark bitmap accordingly */
/*@-nullptrarith@*/
                pMem = (char *) SRAM_BLOCK2ADDR(tagged_block);
/*@=nullptrarith@*/
                *pMem = reqrd_blocks;   /* Set accounting byte */
                pMem++;                 /* The next byte is alloc'd heap space*/
                break;
            } else if (blockused) tagged_a_block = false;   /*not enough blocks,*/
        } else if (!blockused) {        /* ...reset tagged_a_block, start again */
            tagged_a_block = true;      /* if block is free (!blockused), and */
            tagged_block = i;           /* haven't tagged_a_block yet, tag it */
        }
        i++;
    }

#ifdef BMEM_DEBUG
    bprintf(20, "bmal: ONRET: Tag blk %i (%p) for %i blks.\r\n", 
        (sshort)tagged_block, (sshort) pMem, (sshort) reqrd_blocks);
    bprintf(20, "bmal: alc sz @ %p: %i blks = %i.\r\n", 
        pMem - 1, ALLOC_NUMBLOCKS(pMem), ALLOC_NUMBLOCKS(pMem)*SRAM_BLOCKSIZE);
    bprintf(20, "bmal: A2B tst: %i, B2A tst: %p.\r\n", 
        (sshort) SRAM_ADDR2BLOCK(pMem), (sshort) SRAM_BLOCK2ADDR(tagged_block));
    for (i = 0; (i < 10) && (i < SRAM_NUMBLOCKS); i++) {
        /*bsnprintf(tempry, 39, "\tbitmap: %08'B.\r\n", (char) bheap_bitmap[i]);*/
        bprintf(20, "\tbmp: 0x%x.\r\n", (sshort) ((char) bheap_bitmap[i]));
        /*bputs(tempry);*/
    }   /* This code causes badness. */
#endif
    lk_bmalloc = false;
    
    return pMem;
}

#ifdef BREMALLOC

/*@-redef@*/
/*@null@*/ /*@exposed@*/ /*@external@*/
char *bremalloc(ushort size, char /*@exposed@*/ /*@returned@*/ *pExist)
    /*@globals bheap@*/
    /*@modifies *bheap, bheap_bitmap, pExist@*/
/*@=redef@*/
{   
    char /*@exposed@*/ *pMem;
    uchar oldsize, newsize;

#   ifdef BMEM_DEBUG
    oldsize = 0;    /* ... so that printf() says something sane. */
    newsize = 0;
#   endif
    
    pMem = bmalloc(size, pExist);
    if (NULL != pMem) {
        /*newsize ..as opposed to requested */
        newsize = (uchar) ALLOC_NUMBLOCKS(( (uchar *)pMem ))*SRAM_BLOCKSIZE;
        if (NULL != pExist) {
            /* oldsize: actual currently alloc'd bytes.. */
            oldsize = (uchar) (ALLOC_NUMBLOCKS(( (uchar *)pExist ))*(uchar)SRAM_BLOCKSIZE);
            if (newsize > oldsize)
                bmemset(pMem + oldsize, '\0', newsize - oldsize);   /* clear */
            if (pMem != pExist) {                           
                bmemcpy(pMem, pExist, oldsize);                 /* copy */
            }
            bfree(pExist);                                      /* free */
        } else {
            bmemset(pMem, '\0', newsize);   /* newsize, clear ALL granted bytes */
        }
    }

#   ifdef BMEM_DEBUG
/*@-usedef@*/   /* oldsize/newsize may not be defined. Note to self: yes it is */
    bprintf(20, "brem: ONRET: oldsz %i, newsz %i, pMem %p, pExist %p.\r\n"
        , (sshort) oldsize, (sshort) newsize, (sshort) pMem, (sshort) pExist);
/*@=usedef@*/
#   endif

    return pMem;
/*@-mustmod@*/  /*... splint reckons bheap_bitmap isn't modified */
}
/*@=mustmod@*/
#endif

---