Return to malloc_t.c CVS log

Up to [Research Unix] / researchv8dc / cmd / trace

Annotation of researchv8dc/cmd/trace/malloc_t.c, revision 1.1.1.1

1.1       root        1: #include <stdio.h>
                      2: #include "trace.h"
                      3: 
                      4: #define A_LARGE 64
                      5: #define A_USER 0x55000000
                      6: 
                      7: #define POOL   0
                      8: #define ALLOC  1
                      9: #define FREE   2
                     10: #define NREVENT        3
                     11: 
                     12:  union M {
                     13:        long size;
                     14:        union M *link;
                     15:  };
                     16: 
                     17:  union M *freelist[A_LARGE];
                     18:  long   req[A_LARGE];
                     19: 
                     20: char *
                     21: talloc(u)
                     22:        long u;
                     23: { union M *m;
                     24:   register r;
                     25:   char *Smalloc();
                     26: 
                     27:        u = ((u-1)/sizeof(union M) + 2);
                     28: 
                     29:        if( u >= A_LARGE )
                     30:        {       m = (union M *) malloc( u * sizeof(union M) );
                     31:                if (m == NULL)
                     32:                        whoops("malloc fault");
                     33:        } else
                     34:        {       if( freelist[u] == NULL )
                     35:                {       r = req[u] += req[u] ? req[u] : 1;
                     36:                        if (r > NOTOOBIG)
                     37:                                r = req[u] = NOTOOBIG+1;
                     38:                        freelist[u] = (union M *) Smalloc( r*u*sizeof(union M) );
                     39:                        if (freelist[u] == NULL)
                     40:                                whoops("malloc fault");
                     41: 
                     42:                        (freelist[u] + u*(r-1))->link = 0;
                     43:                        for (m = freelist[u] + u*(r-2); m >= freelist[u]; m -= u)
                     44:                                        m->link = m+u;
                     45:                }
                     46: 
                     47:                m = freelist[u];
                     48:                freelist[u] = m->link;
                     49:        }
                     50:        m->size = u | A_USER;
                     51: 
                     52:        return (char *) (m+1);
                     53: }
                     54: 
                     55: tfree(v)
                     56:        char *v;
                     57: { register union M *m = (union M *) v;
                     58:   register long u;
                     59: 
                     60:        --m;
                     61:        if ( (m->size&0xFF000000) != A_USER)
                     62:        {       fprintf(stderr, "releasing a free block\n");
                     63:                kill(getpid(), 3);
                     64:        }
                     65: 
                     66:        u = (m->size &= 0xFFFFFF);
                     67:        if ( u >= A_LARGE )
                     68:                free(m);
                     69:        else
                     70:        {       m->link = freelist[u];
                     71:                freelist[u] = m;
                     72:        }
                     73: }

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