Annotation of OpenXM_contrib/gc/include/new_gc_alloc.h, Revision 1.1.1.1
1.1 maekawa 1: /*
2: * Copyright (c) 1996-1998 by Silicon Graphics. All rights reserved.
3: *
4: * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
5: * OR IMPLIED. ANY USE IS AT YOUR OWN RISK.
6: *
7: * Permission is hereby granted to use or copy this program
8: * for any purpose, provided the above notices are retained on all copies.
9: * Permission to modify the code and to distribute modified code is granted,
10: * provided the above notices are retained, and a notice that the code was
11: * modified is included with the above copyright notice.
12: */
13:
14: //
15: // This is a revision of gc_alloc.h for SGI STL versions > 3.0
16: // Unlike earlier versions, it supplements the standard "alloc.h"
17: // instead of replacing it.
18: //
19: // This is sloppy about variable names used in header files.
20: // It also doesn't yet understand the new header file names or
21: // namespaces.
22: //
23: // This assumes the collector has been compiled with -DATOMIC_UNCOLLECTABLE
24: // and -DALL_INTERIOR_POINTERS. We also recommend
25: // -DREDIRECT_MALLOC=GC_uncollectable_malloc.
26: //
27: // Some of this could be faster in the explicit deallocation case.
28: // In particular, we spend too much time clearing objects on the
29: // free lists. That could be avoided.
30: //
31: // This uses template classes with static members, and hence does not work
32: // with g++ 2.7.2 and earlier.
33: //
34: // Unlike its predecessor, this one simply defines
35: // gc_alloc
36: // single_client_gc_alloc
37: // traceable_alloc
38: // single_client_traceable_alloc
39: //
40: // It does not redefine alloc. Nor does it change the default allocator,
41: // though the user may wish to do so. (The argument against changing
42: // the default allocator is that it may introduce subtle link compatibility
43: // problems. The argument for changing it is that the usual default
44: // allocator is usually a very bad choice for a garbage collected environment.)
45: //
46:
47: #ifndef GC_ALLOC_H
48:
49: #include "gc.h"
50: #include <alloc.h>
51:
52: #define GC_ALLOC_H
53:
54: #include <stddef.h>
55: #include <string.h>
56:
57: // The following need to match collector data structures.
58: // We can't include gc_priv.h, since that pulls in way too much stuff.
59: // This should eventually be factored out into another include file.
60:
61: extern "C" {
62: extern void ** const GC_objfreelist_ptr;
63: extern void ** const GC_aobjfreelist_ptr;
64: extern void ** const GC_uobjfreelist_ptr;
65: extern void ** const GC_auobjfreelist_ptr;
66:
67: extern void GC_incr_words_allocd(size_t words);
68: extern void GC_incr_mem_freed(size_t words);
69:
70: extern char * GC_generic_malloc_words_small(size_t word, int kind);
71: }
72:
73: // Object kinds; must match PTRFREE, NORMAL, UNCOLLECTABLE, and
74: // AUNCOLLECTABLE in gc_priv.h.
75:
76: enum { GC_PTRFREE = 0, GC_NORMAL = 1, GC_UNCOLLECTABLE = 2,
77: GC_AUNCOLLECTABLE = 3 };
78:
79: enum { GC_max_fast_bytes = 255 };
80:
81: enum { GC_bytes_per_word = sizeof(char *) };
82:
83: enum { GC_byte_alignment = 8 };
84:
85: enum { GC_word_alignment = GC_byte_alignment/GC_bytes_per_word };
86:
87: inline void * &GC_obj_link(void * p)
88: { return *(void **)p; }
89:
90: // Compute a number of words >= n+1 bytes.
91: // The +1 allows for pointers one past the end.
92: inline size_t GC_round_up(size_t n)
93: {
94: return ((n + GC_byte_alignment)/GC_byte_alignment)*GC_word_alignment;
95: }
96:
97: // The same but don't allow for extra byte.
98: inline size_t GC_round_up_uncollectable(size_t n)
99: {
100: return ((n + GC_byte_alignment - 1)/GC_byte_alignment)*GC_word_alignment;
101: }
102:
103: template <int dummy>
104: class GC_aux_template {
105: public:
106: // File local count of allocated words. Occasionally this is
107: // added into the global count. A separate count is necessary since the
108: // real one must be updated with a procedure call.
109: static size_t GC_words_recently_allocd;
110:
111: // Same for uncollectable mmory. Not yet reflected in either
112: // GC_words_recently_allocd or GC_non_gc_bytes.
113: static size_t GC_uncollectable_words_recently_allocd;
114:
115: // Similar counter for explicitly deallocated memory.
116: static size_t GC_mem_recently_freed;
117:
118: // Again for uncollectable memory.
119: static size_t GC_uncollectable_mem_recently_freed;
120:
121: static void * GC_out_of_line_malloc(size_t nwords, int kind);
122: };
123:
124: template <int dummy>
125: size_t GC_aux_template<dummy>::GC_words_recently_allocd = 0;
126:
127: template <int dummy>
128: size_t GC_aux_template<dummy>::GC_uncollectable_words_recently_allocd = 0;
129:
130: template <int dummy>
131: size_t GC_aux_template<dummy>::GC_mem_recently_freed = 0;
132:
133: template <int dummy>
134: size_t GC_aux_template<dummy>::GC_uncollectable_mem_recently_freed = 0;
135:
136: template <int dummy>
137: void * GC_aux_template<dummy>::GC_out_of_line_malloc(size_t nwords, int kind)
138: {
139: GC_words_recently_allocd += GC_uncollectable_words_recently_allocd;
140: GC_non_gc_bytes +=
141: GC_bytes_per_word * GC_uncollectable_words_recently_allocd;
142: GC_uncollectable_words_recently_allocd = 0;
143:
144: GC_mem_recently_freed += GC_uncollectable_mem_recently_freed;
145: GC_non_gc_bytes -=
146: GC_bytes_per_word * GC_uncollectable_mem_recently_freed;
147: GC_uncollectable_mem_recently_freed = 0;
148:
149: GC_incr_words_allocd(GC_words_recently_allocd);
150: GC_words_recently_allocd = 0;
151:
152: GC_incr_mem_freed(GC_mem_recently_freed);
153: GC_mem_recently_freed = 0;
154:
155: return GC_generic_malloc_words_small(nwords, kind);
156: }
157:
158: typedef GC_aux_template<0> GC_aux;
159:
160: // A fast, single-threaded, garbage-collected allocator
161: // We assume the first word will be immediately overwritten.
162: // In this version, deallocation is not a noop, and explicit
163: // deallocation is likely to help performance.
164: template <int dummy>
165: class single_client_gc_alloc_template {
166: public:
167: static void * allocate(size_t n)
168: {
169: size_t nwords = GC_round_up(n);
170: void ** flh;
171: void * op;
172:
173: if (n > GC_max_fast_bytes) return GC_malloc(n);
174: flh = GC_objfreelist_ptr + nwords;
175: if (0 == (op = *flh)) {
176: return GC_aux::GC_out_of_line_malloc(nwords, GC_NORMAL);
177: }
178: *flh = GC_obj_link(op);
179: GC_aux::GC_words_recently_allocd += nwords;
180: return op;
181: }
182: static void * ptr_free_allocate(size_t n)
183: {
184: size_t nwords = GC_round_up(n);
185: void ** flh;
186: void * op;
187:
188: if (n > GC_max_fast_bytes) return GC_malloc_atomic(n);
189: flh = GC_aobjfreelist_ptr + nwords;
190: if (0 == (op = *flh)) {
191: return GC_aux::GC_out_of_line_malloc(nwords, GC_PTRFREE);
192: }
193: *flh = GC_obj_link(op);
194: GC_aux::GC_words_recently_allocd += nwords;
195: return op;
196: }
197: static void deallocate(void *p, size_t n)
198: {
199: size_t nwords = GC_round_up(n);
200: void ** flh;
201:
202: if (n > GC_max_fast_bytes) {
203: GC_free(p);
204: } else {
205: flh = GC_objfreelist_ptr + nwords;
206: GC_obj_link(p) = *flh;
207: memset((char *)p + GC_bytes_per_word, 0,
208: GC_bytes_per_word * (nwords - 1));
209: *flh = p;
210: GC_aux::GC_mem_recently_freed += nwords;
211: }
212: }
213: static void ptr_free_deallocate(void *p, size_t n)
214: {
215: size_t nwords = GC_round_up(n);
216: void ** flh;
217:
218: if (n > GC_max_fast_bytes) {
219: GC_free(p);
220: } else {
221: flh = GC_aobjfreelist_ptr + nwords;
222: GC_obj_link(p) = *flh;
223: *flh = p;
224: GC_aux::GC_mem_recently_freed += nwords;
225: }
226: }
227: };
228:
229: typedef single_client_gc_alloc_template<0> single_client_gc_alloc;
230:
231: // Once more, for uncollectable objects.
232: template <int dummy>
233: class single_client_traceable_alloc_template {
234: public:
235: static void * allocate(size_t n)
236: {
237: size_t nwords = GC_round_up_uncollectable(n);
238: void ** flh;
239: void * op;
240:
241: if (n > GC_max_fast_bytes) return GC_malloc_uncollectable(n);
242: flh = GC_uobjfreelist_ptr + nwords;
243: if (0 == (op = *flh)) {
244: return GC_aux::GC_out_of_line_malloc(nwords, GC_UNCOLLECTABLE);
245: }
246: *flh = GC_obj_link(op);
247: GC_aux::GC_uncollectable_words_recently_allocd += nwords;
248: return op;
249: }
250: static void * ptr_free_allocate(size_t n)
251: {
252: size_t nwords = GC_round_up_uncollectable(n);
253: void ** flh;
254: void * op;
255:
256: if (n > GC_max_fast_bytes) return GC_malloc_atomic_uncollectable(n);
257: flh = GC_auobjfreelist_ptr + nwords;
258: if (0 == (op = *flh)) {
259: return GC_aux::GC_out_of_line_malloc(nwords, GC_AUNCOLLECTABLE);
260: }
261: *flh = GC_obj_link(op);
262: GC_aux::GC_uncollectable_words_recently_allocd += nwords;
263: return op;
264: }
265: static void deallocate(void *p, size_t n)
266: {
267: size_t nwords = GC_round_up_uncollectable(n);
268: void ** flh;
269:
270: if (n > GC_max_fast_bytes) {
271: GC_free(p);
272: } else {
273: flh = GC_uobjfreelist_ptr + nwords;
274: GC_obj_link(p) = *flh;
275: *flh = p;
276: GC_aux::GC_uncollectable_mem_recently_freed += nwords;
277: }
278: }
279: static void ptr_free_deallocate(void *p, size_t n)
280: {
281: size_t nwords = GC_round_up_uncollectable(n);
282: void ** flh;
283:
284: if (n > GC_max_fast_bytes) {
285: GC_free(p);
286: } else {
287: flh = GC_auobjfreelist_ptr + nwords;
288: GC_obj_link(p) = *flh;
289: *flh = p;
290: GC_aux::GC_uncollectable_mem_recently_freed += nwords;
291: }
292: }
293: };
294:
295: typedef single_client_traceable_alloc_template<0> single_client_traceable_alloc;
296:
297: template < int dummy >
298: class gc_alloc_template {
299: public:
300: static void * allocate(size_t n) { return GC_malloc(n); }
301: static void * ptr_free_allocate(size_t n)
302: { return GC_malloc_atomic(n); }
303: static void deallocate(void *, size_t) { }
304: static void ptr_free_deallocate(void *, size_t) { }
305: };
306:
307: typedef gc_alloc_template < 0 > gc_alloc;
308:
309: template < int dummy >
310: class traceable_alloc_template {
311: public:
312: static void * allocate(size_t n) { return GC_malloc_uncollectable(n); }
313: static void * ptr_free_allocate(size_t n)
314: { return GC_malloc_atomic_uncollectable(n); }
315: static void deallocate(void *p, size_t) { GC_free(p); }
316: static void ptr_free_deallocate(void *p, size_t) { GC_free(p); }
317: };
318:
319: typedef traceable_alloc_template < 0 > traceable_alloc;
320:
321: #ifdef _SGI_SOURCE
322:
323: // We want to specialize simple_alloc so that it does the right thing
324: // for all pointerfree types. At the moment there is no portable way to
325: // even approximate that. The following approximation should work for
326: // SGI compilers, and perhaps some others.
327:
328: # define __GC_SPECIALIZE(T,alloc) \
329: class simple_alloc<T, alloc> { \
330: public: \
331: static T *allocate(size_t n) \
332: { return 0 == n? 0 : \
333: (T*) alloc::ptr_free_allocate(n * sizeof (T)); } \
334: static T *allocate(void) \
335: { return (T*) alloc::ptr_free_allocate(sizeof (T)); } \
336: static void deallocate(T *p, size_t n) \
337: { if (0 != n) alloc::ptr_free_deallocate(p, n * sizeof (T)); } \
338: static void deallocate(T *p) \
339: { alloc::ptr_free_deallocate(p, sizeof (T)); } \
340: };
341:
342: __GC_SPECIALIZE(char, gc_alloc)
343: __GC_SPECIALIZE(int, gc_alloc)
344: __GC_SPECIALIZE(unsigned, gc_alloc)
345: __GC_SPECIALIZE(float, gc_alloc)
346: __GC_SPECIALIZE(double, gc_alloc)
347:
348: __GC_SPECIALIZE(char, traceable_alloc)
349: __GC_SPECIALIZE(int, traceable_alloc)
350: __GC_SPECIALIZE(unsigned, traceable_alloc)
351: __GC_SPECIALIZE(float, traceable_alloc)
352: __GC_SPECIALIZE(double, traceable_alloc)
353:
354: __GC_SPECIALIZE(char, single_client_gc_alloc)
355: __GC_SPECIALIZE(int, single_client_gc_alloc)
356: __GC_SPECIALIZE(unsigned, single_client_gc_alloc)
357: __GC_SPECIALIZE(float, single_client_gc_alloc)
358: __GC_SPECIALIZE(double, single_client_gc_alloc)
359:
360: __GC_SPECIALIZE(char, single_client_traceable_alloc)
361: __GC_SPECIALIZE(int, single_client_traceable_alloc)
362: __GC_SPECIALIZE(unsigned, single_client_traceable_alloc)
363: __GC_SPECIALIZE(float, single_client_traceable_alloc)
364: __GC_SPECIALIZE(double, single_client_traceable_alloc)
365:
366: #ifdef __STL_USE_STD_ALLOCATORS
367:
368: __STL_BEGIN_NAMESPACE
369:
370: template <class _T>
371: struct _Alloc_traits<_T, gc_alloc >
372: {
373: static const bool _S_instanceless = true;
374: typedef simple_alloc<_T, gc_alloc > _Alloc_type;
375: typedef __allocator<_T, gc_alloc > allocator_type;
376: };
377:
378: inline bool operator==(const gc_alloc&,
379: const gc_alloc&)
380: {
381: return true;
382: }
383:
384: inline bool operator!=(const gc_alloc&,
385: const gc_alloc&)
386: {
387: return false;
388: }
389:
390: template <class _T>
391: struct _Alloc_traits<_T, single_client_gc_alloc >
392: {
393: static const bool _S_instanceless = true;
394: typedef simple_alloc<_T, single_client_gc_alloc > _Alloc_type;
395: typedef __allocator<_T, single_client_gc_alloc > allocator_type;
396: };
397:
398: inline bool operator==(const single_client_gc_alloc&,
399: const single_client_gc_alloc&)
400: {
401: return true;
402: }
403:
404: inline bool operator!=(const single_client_gc_alloc&,
405: const single_client_gc_alloc&)
406: {
407: return false;
408: }
409:
410: template <class _T>
411: struct _Alloc_traits<_T, traceable_alloc >
412: {
413: static const bool _S_instanceless = true;
414: typedef simple_alloc<_T, traceable_alloc > _Alloc_type;
415: typedef __allocator<_T, traceable_alloc > allocator_type;
416: };
417:
418: inline bool operator==(const traceable_alloc&,
419: const traceable_alloc&)
420: {
421: return true;
422: }
423:
424: inline bool operator!=(const traceable_alloc&,
425: const traceable_alloc&)
426: {
427: return false;
428: }
429:
430: template <class _T>
431: struct _Alloc_traits<_T, single_client_traceable_alloc >
432: {
433: static const bool _S_instanceless = true;
434: typedef simple_alloc<_T, single_client_traceable_alloc > _Alloc_type;
435: typedef __allocator<_T, single_client_traceable_alloc > allocator_type;
436: };
437:
438: inline bool operator==(const single_client_traceable_alloc&,
439: const single_client_traceable_alloc&)
440: {
441: return true;
442: }
443:
444: inline bool operator!=(const single_client_traceable_alloc&,
445: const single_client_traceable_alloc&)
446: {
447: return false;
448: }
449:
450: __STL_END_NAMESPACE
451:
452: #endif /* __STL_USE_STD_ALLOCATORS */
453:
454: #endif /* _SGI_SOURCE */
455:
456: #endif /* GC_ALLOC_H */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to new_gc_alloc.h CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [local] / OpenXM_contrib / gc / include