Return to malloc.c CVS log

Up to [Net/2] / Net2 / netiso / xebec

Annotation of Net2/netiso/xebec/malloc.c, revision 1.1.1.2

1.1.1.2 ! root        1: /* $Header: /cvsroot/src/sys/netiso/xebec/malloc.c,v 1.1 1993/04/09 12:02:11 cgd Exp $ */
        !             2: /* $Source: /cvsroot/src/sys/netiso/xebec/malloc.c,v $ */
1.1       root        3: /*
                      4:  * This code is such a kludge that I don't want to put my name on it.
                      5:  * It was a ridiculously fast hack and needs rewriting.
                      6:  * However it does work...
                      7:  */
                      8: 
                      9: /* 
                     10:  * a simple malloc
                     11:  * it might be brain-damaged but for the purposes of xebec
                     12:  * it's a whole lot faster than the c library malloc 
                     13:  */
                     14: 
                     15: #include <stdio.h>
                     16: #include "malloc.h"
                     17: #include "debug.h"
                     18: #define CHUNKSIZE 4096*2
                     19: 
                     20: static char *hiwat, *highend;
                     21: int bytesmalloced=0;
                     22: int byteswasted = 0;
                     23: 
                     24: 
                     25: init_alloc()
                     26: {
                     27: #ifdef LINT
                     28:        hiwat = 0;
                     29:        highend = 0;
                     30: #else LINT
                     31:        extern char *sbrk();
                     32: 
                     33:        hiwat = (char *) sbrk(0);
                     34:        hiwat = (char *)((unsigned)(hiwat + 3) & ~0x3);
                     35:        highend = hiwat;
                     36: #endif LINT
                     37: }
                     38: 
                     39: HIWAT(s)
                     40: char *s;
                     41: {
                     42:        IFDEBUG(M)
                     43:                fprintf(stdout, "HIWAT 0x%x  %s\n", hiwat,s);
                     44:                fflush(stdout);
                     45:        ENDDEBUG
                     46: }
                     47: 
                     48: #define MIN(x,y) ((x<y)?x:y)
                     49: 
                     50: char *Malloc(x)
                     51: int x;
                     52: {
                     53:        char *c;
                     54:        extern char *sbrk();
                     55:        static int firsttime=1;
                     56:        int total = x;
                     57:        int first_iter = 1;
                     58:        char *returnvalue;
                     59: 
                     60:        IFDEBUG(N)
                     61:                fprintf(stdout, "Malloc 0x%x, %d, bytesmalloced %d\n",
                     62:                        total,total, bytesmalloced);
                     63:                fflush(stdout);
                     64:        ENDDEBUG
                     65:        IFDEBUG(M)
                     66:                fprintf(stdout, "Malloc 0x%x, %d, hiwat 0x%x\n",
                     67:                        total,total, hiwat);
                     68:                fflush(stdout);
                     69:        ENDDEBUG
                     70:        if(firsttime) {
                     71:                hiwat = sbrk(0);
                     72:                if(((unsigned)(hiwat) & 0x3)) {
                     73:                        bytesmalloced = 4 - (int) ((unsigned)(hiwat) & 0x3);
                     74:                        hiwat = sbrk( bytesmalloced );
                     75:                } else 
                     76:                        bytesmalloced = 0;
                     77:                firsttime = 0;
                     78:                highend = hiwat;
                     79:        }
                     80:        while( total ) {
                     81:                x = MIN(CHUNKSIZE, total);
                     82:                if(total != x)  {
                     83:                        IFDEBUG(N)
                     84:                                fprintf(stdout, "BIG Malloc tot %d, x %d, left %d net %d\n",
                     85:                                        total,x, total-x, bytesmalloced);
                     86:                                fflush(stdout);
                     87:                        ENDDEBUG
                     88:                }
                     89:                if ( (hiwat + x) > highend) {
                     90:                        c = sbrk(CHUNKSIZE);
                     91:                        IFDEBUG(M)
                     92:                                fprintf(stdout, "hiwat 0x%x, x 0x%x, highend 0x%x, c 0x%x\n",
                     93:                                                hiwat, x, highend, c);
                     94:                                fflush(stdout);
                     95:                        ENDDEBUG
                     96:                        if( c == (char *) -1 ) {
                     97:                                fprintf(stderr, "Ran out of memory!\n");
                     98:                                Exit(-1);
                     99:                        }
                    100:                        if(first_iter) {
                    101:                                returnvalue = c;
                    102:                                first_iter = 0;
                    103:                        }
                    104:                        bytesmalloced +=  CHUNKSIZE;
                    105:                        IFDEBUG(m)
                    106:                                if (highend != c) {
                    107:                                        fprintf(OUT, "warning: %d wasted bytes!\n", highend - hiwat);
                    108:                                fprintf(OUT, " chunksize 0x%x,  x 0x%x \n", CHUNKSIZE, x);
                    109:                                }
                    110:                        ENDDEBUG
                    111:                        highend = c + CHUNKSIZE;
                    112:                        hiwat = c;
                    113:                }
                    114:                c = hiwat;
                    115:                if(first_iter) {
                    116:                        returnvalue = c;
                    117:                        first_iter = 0;
                    118:                }
                    119:                hiwat += x;
                    120:                total -= x;
                    121:        }
                    122:        if((unsigned)hiwat & 0x3) {
                    123:                byteswasted += (int)((unsigned)(hiwat) & 0x3);
                    124:                hiwat = (char *)((unsigned)(hiwat + 3) & ~0x3);
                    125:        }
                    126:        IFDEBUG(M)
                    127:                fprintf(stdout, "Malloc = 0x%x, bytesm 0x%x, wasted 0x%x, hiwat 0x%x\n",
                    128:                        returnvalue, bytesmalloced, byteswasted, hiwat);
                    129:        ENDDEBUG
                    130:        IFDEBUG(N)
                    131:                fprintf(stdout, "Malloc returns 0x%x, sbrk(0) 0x%x\n", returnvalue, sbrk(0));
                    132:                fflush(stdout);
                    133:        ENDDEBUG
                    134:        return(returnvalue);
                    135: }
                    136: 

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