![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to libC.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / jtools / src / pads / host|
Return to libC.c CVS log | Up to [Research Unix] / researchv9 / jtools / src / pads / host |
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.