1da2e3ebdSchin /***********************************************************************
2da2e3ebdSchin * *
3da2e3ebdSchin * This software is part of the ast package *
4*b30d1939SAndy Fiddaman * Copyright (c) 1985-2011 AT&T Intellectual Property *
5da2e3ebdSchin * and is licensed under the *
6*b30d1939SAndy Fiddaman * Eclipse Public License, Version 1.0 *
77c2fbfb3SApril Chin * by AT&T Intellectual Property *
8da2e3ebdSchin * *
9da2e3ebdSchin * A copy of the License is available at *
10*b30d1939SAndy Fiddaman * http://www.eclipse.org/org/documents/epl-v10.html *
11*b30d1939SAndy Fiddaman * (with md5 checksum b35adb5213ca9657e911e9befb180842) *
12da2e3ebdSchin * *
13da2e3ebdSchin * Information and Software Systems Research *
14da2e3ebdSchin * AT&T Research *
15da2e3ebdSchin * Florham Park NJ *
16da2e3ebdSchin * *
17da2e3ebdSchin * Glenn Fowler <gsf@research.att.com> *
18da2e3ebdSchin * David Korn <dgk@research.att.com> *
19da2e3ebdSchin * Phong Vo <kpv@research.att.com> *
20da2e3ebdSchin * *
21da2e3ebdSchin ***********************************************************************/
22da2e3ebdSchin #if defined(_UWIN) && defined(_BLD_ast)
23da2e3ebdSchin
_STUB_vmpool()24da2e3ebdSchin void _STUB_vmpool(){}
25da2e3ebdSchin
26da2e3ebdSchin #else
27da2e3ebdSchin
28da2e3ebdSchin #include "vmhdr.h"
29da2e3ebdSchin
30da2e3ebdSchin #define POOLFREE 0x55555555L /* block free indicator */
31da2e3ebdSchin
32da2e3ebdSchin /* Method for pool allocation.
33da2e3ebdSchin ** All elements in a pool have the same size.
34da2e3ebdSchin ** The following fields of Vmdata_t are used as:
35da2e3ebdSchin ** pool: size of a block.
36da2e3ebdSchin ** free: list of free blocks.
37da2e3ebdSchin **
38da2e3ebdSchin ** Written by Kiem-Phong Vo, kpv@research.att.com, 01/16/94.
39da2e3ebdSchin */
40da2e3ebdSchin
41da2e3ebdSchin #if __STD_C
poolalloc(Vmalloc_t * vm,reg size_t size,int local)42*b30d1939SAndy Fiddaman static Void_t* poolalloc(Vmalloc_t* vm, reg size_t size, int local)
43da2e3ebdSchin #else
44*b30d1939SAndy Fiddaman static Void_t* poolalloc(vm, size, local )
45da2e3ebdSchin Vmalloc_t* vm;
46da2e3ebdSchin reg size_t size;
47*b30d1939SAndy Fiddaman int local;
48da2e3ebdSchin #endif
49da2e3ebdSchin {
50da2e3ebdSchin reg Block_t *tp, *next;
51da2e3ebdSchin reg size_t s;
52*b30d1939SAndy Fiddaman reg Seg_t *seg;
53*b30d1939SAndy Fiddaman reg Vmdata_t *vd = vm->data;
54da2e3ebdSchin
55da2e3ebdSchin if(size <= 0)
56da2e3ebdSchin return NIL(Void_t*);
57*b30d1939SAndy Fiddaman
583e14f97fSRoger A. Faulkner if(size != vd->pool)
59da2e3ebdSchin { if(vd->pool <= 0)
60da2e3ebdSchin vd->pool = size;
61da2e3ebdSchin else return NIL(Void_t*);
62da2e3ebdSchin }
63da2e3ebdSchin
64*b30d1939SAndy Fiddaman SETLOCK(vm, local);
65da2e3ebdSchin
66da2e3ebdSchin if((tp = vd->free) ) /* there is a ready free block */
67da2e3ebdSchin { vd->free = SEGLINK(tp);
68da2e3ebdSchin goto done;
69da2e3ebdSchin }
70da2e3ebdSchin
71da2e3ebdSchin size = ROUND(size,ALIGN);
72da2e3ebdSchin
73da2e3ebdSchin /* look thru all segments for a suitable free block */
74da2e3ebdSchin for(tp = NIL(Block_t*), seg = vd->seg; seg; seg = seg->next)
75da2e3ebdSchin { if((tp = seg->free) &&
76da2e3ebdSchin (s = (SIZE(tp) & ~BITS) + sizeof(Head_t)) >= size )
77*b30d1939SAndy Fiddaman goto got_blk;
78da2e3ebdSchin }
79da2e3ebdSchin
80*b30d1939SAndy Fiddaman if((tp = (*_Vmextend)(vm,ROUND(size,vd->incr),NIL(Vmsearch_f))) )
81*b30d1939SAndy Fiddaman { s = (SIZE(tp) & ~BITS) + sizeof(Head_t);
82*b30d1939SAndy Fiddaman seg = SEG(tp);
83*b30d1939SAndy Fiddaman goto got_blk;
84da2e3ebdSchin }
85*b30d1939SAndy Fiddaman else goto done;
86da2e3ebdSchin
87*b30d1939SAndy Fiddaman got_blk: /* if get here, (tp, s, seg) must be well-defined */
88da2e3ebdSchin next = (Block_t*)((Vmuchar_t*)tp+size);
89da2e3ebdSchin if((s -= size) <= (size + sizeof(Head_t)) )
90da2e3ebdSchin { for(; s >= size; s -= size)
91da2e3ebdSchin { SIZE(next) = POOLFREE;
92da2e3ebdSchin SEGLINK(next) = vd->free;
93da2e3ebdSchin vd->free = next;
94da2e3ebdSchin next = (Block_t*)((Vmuchar_t*)next + size);
95da2e3ebdSchin }
96da2e3ebdSchin seg->free = NIL(Block_t*);
97da2e3ebdSchin }
98da2e3ebdSchin else
99da2e3ebdSchin { SIZE(next) = s - sizeof(Head_t);
100da2e3ebdSchin SEG(next) = seg;
101da2e3ebdSchin seg->free = next;
102da2e3ebdSchin }
103da2e3ebdSchin
104da2e3ebdSchin done:
105da2e3ebdSchin if(!local && (vd->mode&VM_TRACE) && _Vmtrace && tp)
106da2e3ebdSchin (*_Vmtrace)(vm,NIL(Vmuchar_t*),(Vmuchar_t*)tp,vd->pool,0);
107da2e3ebdSchin
108*b30d1939SAndy Fiddaman CLRLOCK(vm, local);
109*b30d1939SAndy Fiddaman
110da2e3ebdSchin return (Void_t*)tp;
111da2e3ebdSchin }
112da2e3ebdSchin
113da2e3ebdSchin #if __STD_C
pooladdr(Vmalloc_t * vm,reg Void_t * addr,int local)114*b30d1939SAndy Fiddaman static long pooladdr(Vmalloc_t* vm, reg Void_t* addr, int local)
115da2e3ebdSchin #else
116*b30d1939SAndy Fiddaman static long pooladdr(vm, addr, local)
117da2e3ebdSchin Vmalloc_t* vm;
118da2e3ebdSchin reg Void_t* addr;
119*b30d1939SAndy Fiddaman int local;
120da2e3ebdSchin #endif
121da2e3ebdSchin {
122*b30d1939SAndy Fiddaman Block_t *bp, *tp;
123*b30d1939SAndy Fiddaman Vmuchar_t *laddr, *baddr;
124*b30d1939SAndy Fiddaman size_t size;
125*b30d1939SAndy Fiddaman Seg_t *seg;
126*b30d1939SAndy Fiddaman long offset;
127*b30d1939SAndy Fiddaman Vmdata_t* vd = vm->data;
128*b30d1939SAndy Fiddaman
129*b30d1939SAndy Fiddaman SETLOCK(vm, local);
130da2e3ebdSchin
131da2e3ebdSchin offset = -1L;
132da2e3ebdSchin for(seg = vd->seg; seg; seg = seg->next)
133da2e3ebdSchin { laddr = (Vmuchar_t*)SEGBLOCK(seg);
134da2e3ebdSchin baddr = seg->baddr-sizeof(Head_t);
135da2e3ebdSchin if((Vmuchar_t*)addr < laddr || (Vmuchar_t*)addr >= baddr)
136da2e3ebdSchin continue;
137da2e3ebdSchin
138da2e3ebdSchin /* the block that has this address */
139da2e3ebdSchin size = ROUND(vd->pool,ALIGN);
140da2e3ebdSchin tp = (Block_t*)(laddr + (((Vmuchar_t*)addr-laddr)/size)*size );
141da2e3ebdSchin
142da2e3ebdSchin /* see if this block has been freed */
143da2e3ebdSchin if(SIZE(tp) == POOLFREE) /* may be a coincidence - make sure */
144da2e3ebdSchin for(bp = vd->free; bp; bp = SEGLINK(bp))
145da2e3ebdSchin if(bp == tp)
146da2e3ebdSchin goto done;
147da2e3ebdSchin
148da2e3ebdSchin offset = (Vmuchar_t*)addr - (Vmuchar_t*)tp;
149da2e3ebdSchin goto done;
150da2e3ebdSchin }
151da2e3ebdSchin
152da2e3ebdSchin done :
153*b30d1939SAndy Fiddaman CLRLOCK(vm, local);
154*b30d1939SAndy Fiddaman
155da2e3ebdSchin return offset;
156da2e3ebdSchin }
157da2e3ebdSchin
158da2e3ebdSchin #if __STD_C
poolfree(reg Vmalloc_t * vm,reg Void_t * data,int local)159*b30d1939SAndy Fiddaman static int poolfree(reg Vmalloc_t* vm, reg Void_t* data, int local )
160da2e3ebdSchin #else
161*b30d1939SAndy Fiddaman static int poolfree(vm, data, local)
162*b30d1939SAndy Fiddaman Vmalloc_t* vm;
163*b30d1939SAndy Fiddaman Void_t* data;
164*b30d1939SAndy Fiddaman int local;
165da2e3ebdSchin #endif
166da2e3ebdSchin {
167*b30d1939SAndy Fiddaman Block_t *bp;
168*b30d1939SAndy Fiddaman Vmdata_t *vd = vm->data;
169da2e3ebdSchin
170da2e3ebdSchin if(!data)
171da2e3ebdSchin return 0;
172*b30d1939SAndy Fiddaman if(vd->pool <= 0)
173*b30d1939SAndy Fiddaman return -1;
174da2e3ebdSchin
175*b30d1939SAndy Fiddaman SETLOCK(vm, local);
176da2e3ebdSchin
177*b30d1939SAndy Fiddaman /**/ASSERT(KPVADDR(vm, data, pooladdr) == 0);
178da2e3ebdSchin bp = (Block_t*)data;
179da2e3ebdSchin SIZE(bp) = POOLFREE;
180da2e3ebdSchin SEGLINK(bp) = vd->free;
181da2e3ebdSchin vd->free = bp;
182da2e3ebdSchin
183da2e3ebdSchin if(!local && (vd->mode&VM_TRACE) && _Vmtrace)
184da2e3ebdSchin (*_Vmtrace)(vm, (Vmuchar_t*)data, NIL(Vmuchar_t*), vd->pool, 0);
185da2e3ebdSchin
186*b30d1939SAndy Fiddaman CLRLOCK(vm, local);
187*b30d1939SAndy Fiddaman
188da2e3ebdSchin return 0;
189da2e3ebdSchin }
190da2e3ebdSchin
191da2e3ebdSchin #if __STD_C
poolresize(Vmalloc_t * vm,Void_t * data,size_t size,int type,int local)192*b30d1939SAndy Fiddaman static Void_t* poolresize(Vmalloc_t* vm, Void_t* data, size_t size, int type, int local )
193da2e3ebdSchin #else
194*b30d1939SAndy Fiddaman static Void_t* poolresize(vm, data, size, type, local )
195da2e3ebdSchin Vmalloc_t* vm;
196da2e3ebdSchin Void_t* data;
197da2e3ebdSchin size_t size;
198da2e3ebdSchin int type;
199*b30d1939SAndy Fiddaman int local;
200da2e3ebdSchin #endif
201da2e3ebdSchin {
202*b30d1939SAndy Fiddaman Vmdata_t *vd = vm->data;
203da2e3ebdSchin
204da2e3ebdSchin NOTUSED(type);
205da2e3ebdSchin
206da2e3ebdSchin if(!data)
207*b30d1939SAndy Fiddaman { data = poolalloc(vm, size, local);
208*b30d1939SAndy Fiddaman if(data && (type&VM_RSZERO) )
209*b30d1939SAndy Fiddaman memset(data, 0, size);
210da2e3ebdSchin return data;
211da2e3ebdSchin }
212da2e3ebdSchin if(size == 0)
213*b30d1939SAndy Fiddaman { (void)poolfree(vm, data, local);
214da2e3ebdSchin return NIL(Void_t*);
215da2e3ebdSchin }
216*b30d1939SAndy Fiddaman if(size != vd->pool)
217*b30d1939SAndy Fiddaman return NIL(Void_t*);
218da2e3ebdSchin
219*b30d1939SAndy Fiddaman SETLOCK(vm, local);
220da2e3ebdSchin
221*b30d1939SAndy Fiddaman /**/ASSERT(KPVADDR(vm, data, pooladdr) == 0);
222da2e3ebdSchin
223*b30d1939SAndy Fiddaman if(!local && (vd->mode&VM_TRACE) && _Vmtrace)
224*b30d1939SAndy Fiddaman (*_Vmtrace)(vm, (Vmuchar_t*)data, (Vmuchar_t*)data, size, 0);
225da2e3ebdSchin
226*b30d1939SAndy Fiddaman CLRLOCK(vm, local);
227da2e3ebdSchin
228da2e3ebdSchin return data;
229da2e3ebdSchin }
230da2e3ebdSchin
231da2e3ebdSchin #if __STD_C
poolsize(Vmalloc_t * vm,Void_t * addr,int local)232*b30d1939SAndy Fiddaman static long poolsize(Vmalloc_t* vm, Void_t* addr, int local)
233da2e3ebdSchin #else
234*b30d1939SAndy Fiddaman static long poolsize(vm, addr, local)
235da2e3ebdSchin Vmalloc_t* vm;
236da2e3ebdSchin Void_t* addr;
237*b30d1939SAndy Fiddaman int local;
238da2e3ebdSchin #endif
239da2e3ebdSchin {
240*b30d1939SAndy Fiddaman return pooladdr(vm, addr, local) == 0 ? (long)vm->data->pool : -1L;
241da2e3ebdSchin }
242da2e3ebdSchin
243da2e3ebdSchin #if __STD_C
poolcompact(Vmalloc_t * vm,int local)244*b30d1939SAndy Fiddaman static int poolcompact(Vmalloc_t* vm, int local)
245da2e3ebdSchin #else
246*b30d1939SAndy Fiddaman static int poolcompact(vm, local)
247da2e3ebdSchin Vmalloc_t* vm;
248*b30d1939SAndy Fiddaman int local;
249da2e3ebdSchin #endif
250da2e3ebdSchin {
251*b30d1939SAndy Fiddaman ssize_t s;
252*b30d1939SAndy Fiddaman Block_t *fp;
253*b30d1939SAndy Fiddaman Seg_t *seg, *next;
254*b30d1939SAndy Fiddaman Vmdata_t *vd = vm->data;
255*b30d1939SAndy Fiddaman
256*b30d1939SAndy Fiddaman SETLOCK(vm, local);
257da2e3ebdSchin
258da2e3ebdSchin for(seg = vd->seg; seg; seg = next)
259da2e3ebdSchin { next = seg->next;
260da2e3ebdSchin
261da2e3ebdSchin if(!(fp = seg->free))
262da2e3ebdSchin continue;
263da2e3ebdSchin
264da2e3ebdSchin seg->free = NIL(Block_t*);
265da2e3ebdSchin if(seg->size == (s = SIZE(fp)&~BITS))
266da2e3ebdSchin s = seg->extent;
267da2e3ebdSchin else s += sizeof(Head_t);
268da2e3ebdSchin
269da2e3ebdSchin if((*_Vmtruncate)(vm,seg,s,1) == s)
270da2e3ebdSchin seg->free = fp;
271da2e3ebdSchin }
272da2e3ebdSchin
273*b30d1939SAndy Fiddaman if(!local && (vd->mode&VM_TRACE) && _Vmtrace)
274da2e3ebdSchin (*_Vmtrace)(vm, (Vmuchar_t*)0, (Vmuchar_t*)0, 0, 0);
275da2e3ebdSchin
276*b30d1939SAndy Fiddaman CLRLOCK(vm, local);
277*b30d1939SAndy Fiddaman
278da2e3ebdSchin return 0;
279da2e3ebdSchin }
280da2e3ebdSchin
281da2e3ebdSchin #if __STD_C
poolalign(Vmalloc_t * vm,size_t size,size_t align,int local)282*b30d1939SAndy Fiddaman static Void_t* poolalign(Vmalloc_t* vm, size_t size, size_t align, int local)
283da2e3ebdSchin #else
284*b30d1939SAndy Fiddaman static Void_t* poolalign(vm, size, align, local)
285da2e3ebdSchin Vmalloc_t* vm;
286da2e3ebdSchin size_t size;
287da2e3ebdSchin size_t align;
288*b30d1939SAndy Fiddaman int local;
289da2e3ebdSchin #endif
290da2e3ebdSchin {
291da2e3ebdSchin NOTUSED(vm);
292da2e3ebdSchin NOTUSED(size);
293da2e3ebdSchin NOTUSED(align);
294da2e3ebdSchin return NIL(Void_t*);
295da2e3ebdSchin }
296da2e3ebdSchin
297da2e3ebdSchin /* Public interface */
298da2e3ebdSchin static Vmethod_t _Vmpool =
299da2e3ebdSchin {
300da2e3ebdSchin poolalloc,
301da2e3ebdSchin poolresize,
302da2e3ebdSchin poolfree,
303da2e3ebdSchin pooladdr,
304da2e3ebdSchin poolsize,
305da2e3ebdSchin poolcompact,
306da2e3ebdSchin poolalign,
307da2e3ebdSchin VM_MTPOOL
308da2e3ebdSchin };
309da2e3ebdSchin
310da2e3ebdSchin __DEFINE__(Vmethod_t*,Vmpool,&_Vmpool);
311da2e3ebdSchin
312da2e3ebdSchin #ifdef NoF
313da2e3ebdSchin NoF(vmpool)
314da2e3ebdSchin #endif
315da2e3ebdSchin
316da2e3ebdSchin #endif
317