Return to libC.c CVS log

Up to [Research Unix] / researchv9 / jtools / src / pads / host

Annotation of researchv9/jtools/src/pads/host/libC.c, revision 1.1

1.1     ! root        1: //#define A_LARGE 64
        !             2: //#define A_USER 0x55000000
        !             3: //
        !             4: //void PadsError(char* ...);
        !             5: //
        !             6: //enum Event { POOL=0, ALLOC=1, FREE=2, EVENT=3 };
        !             7: //
        !             8: //#define      log(e, u, d) { event[u][e] += d; }
        !             9: //
        !            10: //class Allocator {
        !            11: //     union M {
        !            12: //             long size;
        !            13: //             M    *link;
        !            14: //     };
        !            15: //     M       *freelist[A_LARGE];
        !            16: //     long    req[A_LARGE];
        !            17: //     long    event[A_LARGE][EVENT];
        !            18: //public:
        !            19: //     void    *alloc(long);
        !            20: //     void    free(void*);
        !            21: //     char    *profile(long);
        !            22: //
        !            23: //};
        !            24: //
        !            25: //Allocator NewDel;
        !            26: //
        !            27: //char *Allocator.profile(long u)
        !            28: //{
        !            29: //     static char report[64];
        !            30: //     long p = event[u][POOL], a = event[u][ALLOC], f = event[u][FREE];
        !            31: //
        !            32: //     if( u >= A_LARGE ) return 0;
        !            33: //     if( !(p|a|f) ) return "";
        !            34: //     u = u ? (u-1)*sizeof(M) : 0;
        !            35: //     sprintf(report, "size=%3d: pool=%4d new=%4d del=%4d tot=%8d",
        !            36: //             u, p, a, f, (u+4)*p);
        !            37: //     return report;
        !            38: //}
        !            39: //
        !            40: //void *Allocator.alloc(register long u)
        !            41: //{
        !            42: //     M *malloc(long);
        !            43: //     register M *m;
        !            44: //     register r;
        !            45: //
        !            46: //     if( u <= 0 ) PadsError( "Allocator.alloc(%d)", u );
        !            47: //     u = ((u-1)/sizeof(M)) + 2;
        !            48: //     if( u >= A_LARGE ){
        !            49: //             log(ALLOC,0,u*sizeof(M));
        !            50: //             m = malloc(u*sizeof(M));
        !            51: //             if( !m ) PadsError("host out of memory");
        !            52: //     } else {
        !            53: //             if( !freelist[u] ){
        !            54: //                     if( req[u] == 0 ) req[u] = 1;
        !            55: //                     r = req[u];
        !            56: //                     if( req[u] < 256 ) req[u] *= 2;
        !            57: //                     log(POOL,u,r);
        !            58: //                     freelist[u] = malloc(r*u*sizeof(M));
        !            59: //                     if( !freelist[u] ) PadsError("host out of memory");
        !            60: //                     for( m = freelist[u]; --r > 0; m = m->link = m+u );
        !            61: //                     m->link = 0;
        !            62: //             }
        !            63: //             log(ALLOC,u,1);
        !            64: //             m = freelist[u];
        !            65: //             freelist[u] = m->link;
        !            66: //     }
        !            67: //     m->size = u|A_USER;
        !            68: //     for( r = 1; r < u; )
        !            69: //             (&m->size)[r++] = 0;
        !            70: //     return m+1;
        !            71: //}
        !            72: //
        !            73: //void Allocator.free(void *v)
        !            74: //{
        !            75: //     void free(M*);
        !            76: //     register M* m = (M*) v;
        !            77: //     register long u;
        !            78: //
        !            79: //     --m;
        !            80: //     if( (m->size&0xFF000000) != A_USER ) PadsError( "delete error" );
        !            81: //     u = (m->size &= 0xFFFFFF);
        !            82: //     if( u >= A_LARGE ){
        !            83: //             log(FREE,0,u*sizeof(M));
        !            84: //             ::free(m);
        !            85: //     }
        !            86: //     else {
        !            87: //             log(FREE,u,1);
        !            88: //             m->link = freelist[u];
        !            89: //             freelist[u] = m;
        !            90: //     }
        !            91: //}
        !            92: 
        !            93: typedef void* PV;
        !            94: typedef void (*PF)(PV);
        !            95: 
        !            96: void *operator new(long size)
        !            97: {
        !            98:        void *calloc(unsigned, unsigned);
        !            99:        if( size<= 0 ) PadsError("new(%d)", size);
        !           100:        return calloc(size, 1);                         // NewDel.alloc(size);
        !           101: }
        !           102: 
        !           103: void operator delete(PV p)
        !           104: {
        !           105:        void free(void*);
        !           106:        if(p) free(p);                                  // NewDel.free(p);
        !           107: }
        !           108: 
        !           109: PV _vec_new(PV op, int n, int sz, PV f)
        !           110: {
        !           111:        register int i;
        !           112:        register char* p;
        !           113:        if (op == 0) op = PV( new char[n*sz] );
        !           114:        p = (char*) op;
        !           115:        for (i=0; i<n; i++) ( *PF(f) )( PV(p+i*sz) );
        !           116:        return PV(p);
        !           117: }
        !           118: 
        !           119: void _vec_delete(PV op, int n, int sz, PV f, int)      // what is that last int?
        !           120: {
        !           121:        register int i;
        !           122:        register char* p = (char*) op;
        !           123:        for (i=0; i<n; i++) ( *(PF)f )( (PV)(p+i*sz) );
        !           124: }
        !           125: 
        !           126: extern void _main() {}

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