Return to mem.c CVS log

Up to [Research Unix] / researchv10no / cmd / twig

Annotation of researchv10no/cmd/twig/mem.c, revision 1.1

1.1     ! root        1: #include <stdio.h>
        !             2: #include <assert.h>
        !             3: #include "mem.h"
        !             4: 
        !             5: #define BLKF    100
        !             6: 
        !             7: static struct _mem *mlist;
        !             8: 
        !             9: static void
        !            10: zap(cp,size)
        !            11:         char *cp;
        !            12:         int size;
        !            13: {
        !            14:         for(;size>0;size--) {
        !            15:                 *cp = 0xff;
        !            16:         }
        !            17: }
        !            18: void
        !            19: mem_init(mp, size)
        !            20:         struct _mem *mp;
        !            21:         int size;
        !            22: {
        !            23:         int i, s;
        !            24:         assert(size>=4);
        !            25:         mp->size = s = size;
        !            26:         s *= BLKF;
        !            27:         for (i=1; i < s; i <<= 1);
        !            28:         mp->bsize = i;
        !            29:         mp->blkf = mp->bsize/size;
        !            30:         mp->cnt = 0;
        !            31:         mp->freelist = NULL;
        !            32:         mp->totelem = 0;
        !            33:         mp->freecnt = 0;
        !            34:         mp->next = mlist;
        !            35:         mlist = mp;
        !            36: };
        !            37: 
        !            38: char *
        !            39: mem_get(mp)
        !            40:         struct _mem *mp;
        !            41: {
        !            42:         char *cp;
        !            43:         if (mp->freelist!=NULL) {
        !            44:                 cp = mp->freelist;
        !            45:                 mp->freelist = *(char **) cp;
        !            46:                 mp->freecnt--;
        !            47:                 zap(cp,mp->size);
        !            48:                 return(cp);
        !            49:         } else if (mp->cnt==0) {
        !            50:                 mp->block = (char *)malloc(mp->bsize);
        !            51:                 mp->cnt = mp->blkf;
        !            52:                 mp->totelem += mp->blkf;
        !            53:         }
        !            54:         mp->cnt--;
        !            55:         cp = mp->block;
        !            56:         mp->block += mp->size;
        !            57:         zap(cp,mp->size);
        !            58:         return(cp);
        !            59: }
        !            60:                 
        !            61: mem_free(mp, cp)
        !            62:         struct _mem *mp;
        !            63:         char *cp;{
        !            64:         *(char **)cp = mp->freelist;
        !            65:         mp->freelist = cp;
        !            66:         mp->freecnt++;
        !            67: }
        !            68: 
        !            69: mem_outstanding(mp)
        !            70:         struct _mem *mp;
        !            71: {
        !            72:         /* returns elements that are outstanding..i.e. asked for
        !            73:          * but haven't yet been returned
        !            74:          */
        !            75:         return(mp->totelem - (mp->cnt+mp->freecnt));
        !            76: }
        !            77: 
        !            78: mem_epilogue()
        !            79: {
        !            80:         struct _mem *mp;
        !            81:         /*
        !            82:          * if the following assertion fails then one of the following
        !            83:          * has happened:
        !            84:          * 1) somebody forgot to free something or
        !            85:          * 2) there is leakage.
        !            86:          */
        !            87:         for(mp=mlist; mp!=NULL; mp = mp->next) {
        !            88:                 assert(mem_outstanding(mp)==0);
        !            89:         }
        !            90: }

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.