Return to alloc.c CVS log

Up to [Research Unix] / researchv9 / jtools / src / sam

Annotation of researchv9/jtools/src/sam/alloc.c, revision 1.1.1.1

1.1       root        1: #include "sam.h"
                      2: /*
                      3:  *     Allocator.  Manages arena between initial bss and garbage-compacted
                      4:  *     arena.  Uses shiftgcarena() when it needs to expand its dominion.
                      5:  */
                      6: 
                      7: #define        BRKINCR         4096
                      8: #define        LBRKINCR        (BRKINCR/sizeof(long))
                      9: 
                     10: #define        FREE            1
                     11: typedef struct hdr{
                     12:        union{
                     13:                long    *Unext; /* pointer to next object */
                     14:                long    Uinext; /* integer next; odd if deallocated */
                     15:        }uu;
                     16:        long    nlongs;
                     17: }hdr;
                     18: #define        inext   uu.Uinext
                     19: #define        next    uu.Unext
                     20: #define        hp      ((struct hdr *)p)
                     21: 
                     22: #define        HEADERSIZE      (sizeof(struct hdr)/sizeof(long))
                     23: 
                     24: static long    *basep;         /* beginning of arena; only set once */
                     25: static long    *endp;          /* end of arena */
                     26: static long    *nextp;         /* next one to be used */
                     27: 
                     28: allocinit(){
                     29:        basep=(long *)sbrk(0);
                     30:        if(brk((char *)(basep+LBRKINCR))!=0)
                     31:                error(Ealloc);
                     32:        nextp=basep;
                     33:        endp=basep+LBRKINCR;
                     34: }
                     35: uchar *
                     36: alloc(nbytes)
                     37:        register ulong nbytes;
                     38: {
                     39:        register long *p, *q;
                     40:        register ulong nl;
                     41:        nbytes+=sizeof(long)-1;
                     42:        nbytes/=sizeof(long);   /* convert bytes to longs */
                     43: #define        Nlongs  nbytes
                     44:        Nlongs+=HEADERSIZE;
                     45:        /* look for exact match */
                     46:        for(p=basep; p<nextp; p=(long *)(hp->inext&~FREE))
                     47:                if((hp->inext&FREE) && hp->nlongs==Nlongs){
                     48:                        hp->inext&=~FREE;
                     49:                        goto Return;
                     50:                }
                     51:        /* try off the end */
                     52:        if(endp-nextp < Nlongs){
                     53:                nl=(nextp+Nlongs)-basep;                /* number we need */
                     54:                nl=((nl+LBRKINCR-1)/LBRKINCR)*LBRKINCR; /* rounded up */
                     55:                nl-=(endp-basep);                       /* minus number we have */
                     56:                if((int)sbrk((int)(nl*sizeof(long)))==-1)
                     57:                        error(Ealloc);
                     58:                shiftgcarena(nl);
                     59:                endp+=nl;
                     60:        }
                     61:        p=nextp;
                     62:        nextp+=Nlongs;
                     63:        hp->nlongs=Nlongs;
                     64:        hp->next=nextp;
                     65:     Return:
                     66:        for(q=p+HEADERSIZE, Nlongs-=HEADERSIZE; Nlongs-->0; )
                     67:                *q++=0;
                     68:        return (uchar *)(p+HEADERSIZE);
                     69: }
                     70: free(cp)
                     71:        uchar *cp;
                     72: {
                     73:        register long *p=(long *)cp;
                     74:        if(p<=basep || nextp<=p)
                     75:                panic("free");
                     76:        p-=HEADERSIZE;
                     77:        hp->inext|=FREE;
                     78: }

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