Annotation of OpenXM_contrib/gc/gc_alloc.h, Revision 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 C++ header file that is intended to replace the SGI STL
! 16: // alloc.h.
! 17: //
! 18: // This assumes the collector has been compiled with -DATOMIC_UNCOLLECTABLE
! 19: // and -DALL_INTERIOR_POINTERS. We also recommend
! 20: // -DREDIRECT_MALLOC=GC_uncollectable_malloc.
! 21: //
! 22: // Some of this could be faster in the explicit deallocation case. In particular,
! 23: // we spend too much time clearing objects on the free lists. That could be avoided.
! 24: //
! 25: // This uses template classes with static members, and hence does not work
! 26: // with g++ 2.7.2 and earlier.
! 27: //
! 28:
! 29: #include "gc.h"
! 30:
! 31: #ifndef GC_ALLOC_H
! 32:
! 33: #define GC_ALLOC_H
! 34: #define __ALLOC_H // Prevent inclusion of the default version. Ugly.
! 35: #define __SGI_STL_ALLOC_H
! 36: #define __SGI_STL_INTERNAL_ALLOC_H
! 37:
! 38: #ifndef __ALLOC
! 39: # define __ALLOC alloc
! 40: #endif
! 41:
! 42: #include <stddef.h>
! 43: #include <string.h>
! 44:
! 45: // The following is just replicated from the conventional SGI alloc.h:
! 46:
! 47: template<class T, class alloc>
! 48: class simple_alloc {
! 49:
! 50: public:
! 51: static T *allocate(size_t n)
! 52: { return 0 == n? 0 : (T*) alloc::allocate(n * sizeof (T)); }
! 53: static T *allocate(void)
! 54: { return (T*) alloc::allocate(sizeof (T)); }
! 55: static void deallocate(T *p, size_t n)
! 56: { if (0 != n) alloc::deallocate(p, n * sizeof (T)); }
! 57: static void deallocate(T *p)
! 58: { alloc::deallocate(p, sizeof (T)); }
! 59: };
! 60:
! 61: #include "gc.h"
! 62:
! 63: // The following need to match collector data structures.
! 64: // We can't include gc_priv.h, since that pulls in way too much stuff.
! 65: // This should eventually be factored out into another include file.
! 66:
! 67: extern "C" {
! 68: extern void ** const GC_objfreelist_ptr;
! 69: extern void ** const GC_aobjfreelist_ptr;
! 70: extern void ** const GC_uobjfreelist_ptr;
! 71: extern void ** const GC_auobjfreelist_ptr;
! 72:
! 73: extern void GC_incr_words_allocd(size_t words);
! 74: extern void GC_incr_mem_freed(size_t words);
! 75:
! 76: extern char * GC_generic_malloc_words_small(size_t word, int kind);
! 77: }
! 78:
! 79: // Object kinds; must match PTRFREE, NORMAL, UNCOLLECTABLE, and
! 80: // AUNCOLLECTABLE in gc_priv.h.
! 81:
! 82: enum { GC_PTRFREE = 0, GC_NORMAL = 1, GC_UNCOLLECTABLE = 2,
! 83: GC_AUNCOLLECTABLE = 3 };
! 84:
! 85: enum { GC_max_fast_bytes = 255 };
! 86:
! 87: enum { GC_bytes_per_word = sizeof(char *) };
! 88:
! 89: enum { GC_byte_alignment = 8 };
! 90:
! 91: enum { GC_word_alignment = GC_byte_alignment/GC_bytes_per_word };
! 92:
! 93: inline void * &GC_obj_link(void * p)
! 94: { return *(void **)p; }
! 95:
! 96: // Compute a number of words >= n+1 bytes.
! 97: // The +1 allows for pointers one past the end.
! 98: inline size_t GC_round_up(size_t n)
! 99: {
! 100: return ((n + GC_byte_alignment)/GC_byte_alignment)*GC_word_alignment;
! 101: }
! 102:
! 103: // The same but don't allow for extra byte.
! 104: inline size_t GC_round_up_uncollectable(size_t n)
! 105: {
! 106: return ((n + GC_byte_alignment - 1)/GC_byte_alignment)*GC_word_alignment;
! 107: }
! 108:
! 109: template <int dummy>
! 110: class GC_aux_template {
! 111: public:
! 112: // File local count of allocated words. Occasionally this is
! 113: // added into the global count. A separate count is necessary since the
! 114: // real one must be updated with a procedure call.
! 115: static size_t GC_words_recently_allocd;
! 116:
! 117: // Same for uncollectable mmory. Not yet reflected in either
! 118: // GC_words_recently_allocd or GC_non_gc_bytes.
! 119: static size_t GC_uncollectable_words_recently_allocd;
! 120:
! 121: // Similar counter for explicitly deallocated memory.
! 122: static size_t GC_mem_recently_freed;
! 123:
! 124: // Again for uncollectable memory.
! 125: static size_t GC_uncollectable_mem_recently_freed;
! 126:
! 127: static void * GC_out_of_line_malloc(size_t nwords, int kind);
! 128: };
! 129:
! 130: template <int dummy>
! 131: size_t GC_aux_template<dummy>::GC_words_recently_allocd = 0;
! 132:
! 133: template <int dummy>
! 134: size_t GC_aux_template<dummy>::GC_uncollectable_words_recently_allocd = 0;
! 135:
! 136: template <int dummy>
! 137: size_t GC_aux_template<dummy>::GC_mem_recently_freed = 0;
! 138:
! 139: template <int dummy>
! 140: size_t GC_aux_template<dummy>::GC_uncollectable_mem_recently_freed = 0;
! 141:
! 142: template <int dummy>
! 143: void * GC_aux_template<dummy>::GC_out_of_line_malloc(size_t nwords, int kind)
! 144: {
! 145: GC_words_recently_allocd += GC_uncollectable_words_recently_allocd;
! 146: GC_non_gc_bytes +=
! 147: GC_bytes_per_word * GC_uncollectable_words_recently_allocd;
! 148: GC_uncollectable_words_recently_allocd = 0;
! 149:
! 150: GC_mem_recently_freed += GC_uncollectable_mem_recently_freed;
! 151: GC_non_gc_bytes -=
! 152: GC_bytes_per_word * GC_uncollectable_mem_recently_freed;
! 153: GC_uncollectable_mem_recently_freed = 0;
! 154:
! 155: GC_incr_words_allocd(GC_words_recently_allocd);
! 156: GC_words_recently_allocd = 0;
! 157:
! 158: GC_incr_mem_freed(GC_mem_recently_freed);
! 159: GC_mem_recently_freed = 0;
! 160:
! 161: return GC_generic_malloc_words_small(nwords, kind);
! 162: }
! 163:
! 164: typedef GC_aux_template<0> GC_aux;
! 165:
! 166: // A fast, single-threaded, garbage-collected allocator
! 167: // We assume the first word will be immediately overwritten.
! 168: // In this version, deallocation is not a noop, and explicit
! 169: // deallocation is likely to help performance.
! 170: template <int dummy>
! 171: class single_client_gc_alloc_template {
! 172: public:
! 173: static void * allocate(size_t n)
! 174: {
! 175: size_t nwords = GC_round_up(n);
! 176: void ** flh;
! 177: void * op;
! 178:
! 179: if (n > GC_max_fast_bytes) return GC_malloc(n);
! 180: flh = GC_objfreelist_ptr + nwords;
! 181: if (0 == (op = *flh)) {
! 182: return GC_aux::GC_out_of_line_malloc(nwords, GC_NORMAL);
! 183: }
! 184: *flh = GC_obj_link(op);
! 185: GC_aux::GC_words_recently_allocd += nwords;
! 186: return op;
! 187: }
! 188: static void * ptr_free_allocate(size_t n)
! 189: {
! 190: size_t nwords = GC_round_up(n);
! 191: void ** flh;
! 192: void * op;
! 193:
! 194: if (n > GC_max_fast_bytes) return GC_malloc_atomic(n);
! 195: flh = GC_aobjfreelist_ptr + nwords;
! 196: if (0 == (op = *flh)) {
! 197: return GC_aux::GC_out_of_line_malloc(nwords, GC_PTRFREE);
! 198: }
! 199: *flh = GC_obj_link(op);
! 200: GC_aux::GC_words_recently_allocd += nwords;
! 201: return op;
! 202: }
! 203: static void deallocate(void *p, size_t n)
! 204: {
! 205: size_t nwords = GC_round_up(n);
! 206: void ** flh;
! 207:
! 208: if (n > GC_max_fast_bytes) {
! 209: GC_free(p);
! 210: } else {
! 211: flh = GC_objfreelist_ptr + nwords;
! 212: GC_obj_link(p) = *flh;
! 213: memset((char *)p + GC_bytes_per_word, 0,
! 214: GC_bytes_per_word * (nwords - 1));
! 215: *flh = p;
! 216: GC_aux::GC_mem_recently_freed += nwords;
! 217: }
! 218: }
! 219: static void ptr_free_deallocate(void *p, size_t n)
! 220: {
! 221: size_t nwords = GC_round_up(n);
! 222: void ** flh;
! 223:
! 224: if (n > GC_max_fast_bytes) {
! 225: GC_free(p);
! 226: } else {
! 227: flh = GC_aobjfreelist_ptr + nwords;
! 228: GC_obj_link(p) = *flh;
! 229: *flh = p;
! 230: GC_aux::GC_mem_recently_freed += nwords;
! 231: }
! 232: }
! 233: };
! 234:
! 235: typedef single_client_gc_alloc_template<0> single_client_gc_alloc;
! 236:
! 237: // Once more, for uncollectable objects.
! 238: template <int dummy>
! 239: class single_client_alloc_template {
! 240: public:
! 241: static void * allocate(size_t n)
! 242: {
! 243: size_t nwords = GC_round_up_uncollectable(n);
! 244: void ** flh;
! 245: void * op;
! 246:
! 247: if (n > GC_max_fast_bytes) return GC_malloc_uncollectable(n);
! 248: flh = GC_uobjfreelist_ptr + nwords;
! 249: if (0 == (op = *flh)) {
! 250: return GC_aux::GC_out_of_line_malloc(nwords, GC_UNCOLLECTABLE);
! 251: }
! 252: *flh = GC_obj_link(op);
! 253: GC_aux::GC_uncollectable_words_recently_allocd += nwords;
! 254: return op;
! 255: }
! 256: static void * ptr_free_allocate(size_t n)
! 257: {
! 258: size_t nwords = GC_round_up_uncollectable(n);
! 259: void ** flh;
! 260: void * op;
! 261:
! 262: if (n > GC_max_fast_bytes) return GC_malloc_atomic_uncollectable(n);
! 263: flh = GC_auobjfreelist_ptr + nwords;
! 264: if (0 == (op = *flh)) {
! 265: return GC_aux::GC_out_of_line_malloc(nwords, GC_AUNCOLLECTABLE);
! 266: }
! 267: *flh = GC_obj_link(op);
! 268: GC_aux::GC_uncollectable_words_recently_allocd += nwords;
! 269: return op;
! 270: }
! 271: static void deallocate(void *p, size_t n)
! 272: {
! 273: size_t nwords = GC_round_up_uncollectable(n);
! 274: void ** flh;
! 275:
! 276: if (n > GC_max_fast_bytes) {
! 277: GC_free(p);
! 278: } else {
! 279: flh = GC_uobjfreelist_ptr + nwords;
! 280: GC_obj_link(p) = *flh;
! 281: *flh = p;
! 282: GC_aux::GC_uncollectable_mem_recently_freed += nwords;
! 283: }
! 284: }
! 285: static void ptr_free_deallocate(void *p, size_t n)
! 286: {
! 287: size_t nwords = GC_round_up_uncollectable(n);
! 288: void ** flh;
! 289:
! 290: if (n > GC_max_fast_bytes) {
! 291: GC_free(p);
! 292: } else {
! 293: flh = GC_auobjfreelist_ptr + nwords;
! 294: GC_obj_link(p) = *flh;
! 295: *flh = p;
! 296: GC_aux::GC_uncollectable_mem_recently_freed += nwords;
! 297: }
! 298: }
! 299: };
! 300:
! 301: typedef single_client_alloc_template<0> single_client_alloc;
! 302:
! 303: template < int dummy >
! 304: class gc_alloc_template {
! 305: public:
! 306: static void * allocate(size_t n) { return GC_malloc(n); }
! 307: static void * ptr_free_allocate(size_t n)
! 308: { return GC_malloc_atomic(n); }
! 309: static void deallocate(void *, size_t) { }
! 310: static void ptr_free_deallocate(void *, size_t) { }
! 311: };
! 312:
! 313: typedef gc_alloc_template < 0 > gc_alloc;
! 314:
! 315: template < int dummy >
! 316: class alloc_template {
! 317: public:
! 318: static void * allocate(size_t n) { return GC_malloc_uncollectable(n); }
! 319: static void * ptr_free_allocate(size_t n)
! 320: { return GC_malloc_atomic_uncollectable(n); }
! 321: static void deallocate(void *p, size_t) { GC_free(p); }
! 322: static void ptr_free_deallocate(void *p, size_t) { GC_free(p); }
! 323: };
! 324:
! 325: typedef alloc_template < 0 > alloc;
! 326:
! 327: #ifdef _SGI_SOURCE
! 328:
! 329: // We want to specialize simple_alloc so that it does the right thing
! 330: // for all pointerfree types. At the moment there is no portable way to
! 331: // even approximate that. The following approximation should work for
! 332: // SGI compilers, and perhaps some others.
! 333:
! 334: # define __GC_SPECIALIZE(T,alloc) \
! 335: class simple_alloc<T, alloc> { \
! 336: public: \
! 337: static T *allocate(size_t n) \
! 338: { return 0 == n? 0 : \
! 339: (T*) alloc::ptr_free_allocate(n * sizeof (T)); } \
! 340: static T *allocate(void) \
! 341: { return (T*) alloc::ptr_free_allocate(sizeof (T)); } \
! 342: static void deallocate(T *p, size_t n) \
! 343: { if (0 != n) alloc::ptr_free_deallocate(p, n * sizeof (T)); } \
! 344: static void deallocate(T *p) \
! 345: { alloc::ptr_free_deallocate(p, sizeof (T)); } \
! 346: };
! 347:
! 348: __GC_SPECIALIZE(char, gc_alloc)
! 349: __GC_SPECIALIZE(int, gc_alloc)
! 350: __GC_SPECIALIZE(unsigned, gc_alloc)
! 351: __GC_SPECIALIZE(float, gc_alloc)
! 352: __GC_SPECIALIZE(double, gc_alloc)
! 353:
! 354: __GC_SPECIALIZE(char, alloc)
! 355: __GC_SPECIALIZE(int, alloc)
! 356: __GC_SPECIALIZE(unsigned, alloc)
! 357: __GC_SPECIALIZE(float, alloc)
! 358: __GC_SPECIALIZE(double, alloc)
! 359:
! 360: __GC_SPECIALIZE(char, single_client_gc_alloc)
! 361: __GC_SPECIALIZE(int, single_client_gc_alloc)
! 362: __GC_SPECIALIZE(unsigned, single_client_gc_alloc)
! 363: __GC_SPECIALIZE(float, single_client_gc_alloc)
! 364: __GC_SPECIALIZE(double, single_client_gc_alloc)
! 365:
! 366: __GC_SPECIALIZE(char, single_client_alloc)
! 367: __GC_SPECIALIZE(int, single_client_alloc)
! 368: __GC_SPECIALIZE(unsigned, single_client_alloc)
! 369: __GC_SPECIALIZE(float, single_client_alloc)
! 370: __GC_SPECIALIZE(double, single_client_alloc)
! 371:
! 372: #ifdef __STL_USE_STD_ALLOCATORS
! 373:
! 374: ???copy stuff from stl_alloc.h or remove it to a different file ???
! 375:
! 376: #endif /* __STL_USE_STD_ALLOCATORS */
! 377:
! 378: #endif /* _SGI_SOURCE */
! 379:
! 380: #endif /* GC_ALLOC_H */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to 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