[BACK]Return to new_gc_alloc.h CVS log [TXT][DIR] Up to [local] / OpenXM_contrib2 / asir2000 / gc5.3 / include

Annotation of OpenXM_contrib2/asir2000/gc5.3/include/new_gc_alloc.h, Revision 1.1.1.1

1.1       noro        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: // We want to specialize simple_alloc so that it does the right thing
                    322: // for all pointerfree types.  At the moment there is no portable way to
                    323: // even approximate that.  The following approximation should work for
                    324: // SGI compilers, and recent versions of g++.
                    325:
                    326: # define __GC_SPECIALIZE(T,alloc) \
                    327: class simple_alloc<T, alloc> { \
                    328: public: \
                    329:     static T *allocate(size_t n) \
                    330:        { return 0 == n? 0 : \
                    331:                         (T*) alloc::ptr_free_allocate(n * sizeof (T)); } \
                    332:     static T *allocate(void) \
                    333:        { return (T*) alloc::ptr_free_allocate(sizeof (T)); } \
                    334:     static void deallocate(T *p, size_t n) \
                    335:        { if (0 != n) alloc::ptr_free_deallocate(p, n * sizeof (T)); } \
                    336:     static void deallocate(T *p) \
                    337:        { alloc::ptr_free_deallocate(p, sizeof (T)); } \
                    338: };
                    339:
                    340: __GC_SPECIALIZE(char, gc_alloc)
                    341: __GC_SPECIALIZE(int, gc_alloc)
                    342: __GC_SPECIALIZE(unsigned, gc_alloc)
                    343: __GC_SPECIALIZE(float, gc_alloc)
                    344: __GC_SPECIALIZE(double, gc_alloc)
                    345:
                    346: __GC_SPECIALIZE(char, traceable_alloc)
                    347: __GC_SPECIALIZE(int, traceable_alloc)
                    348: __GC_SPECIALIZE(unsigned, traceable_alloc)
                    349: __GC_SPECIALIZE(float, traceable_alloc)
                    350: __GC_SPECIALIZE(double, traceable_alloc)
                    351:
                    352: __GC_SPECIALIZE(char, single_client_gc_alloc)
                    353: __GC_SPECIALIZE(int, single_client_gc_alloc)
                    354: __GC_SPECIALIZE(unsigned, single_client_gc_alloc)
                    355: __GC_SPECIALIZE(float, single_client_gc_alloc)
                    356: __GC_SPECIALIZE(double, single_client_gc_alloc)
                    357:
                    358: __GC_SPECIALIZE(char, single_client_traceable_alloc)
                    359: __GC_SPECIALIZE(int, single_client_traceable_alloc)
                    360: __GC_SPECIALIZE(unsigned, single_client_traceable_alloc)
                    361: __GC_SPECIALIZE(float, single_client_traceable_alloc)
                    362: __GC_SPECIALIZE(double, single_client_traceable_alloc)
                    363:
                    364: #ifdef __STL_USE_STD_ALLOCATORS
                    365:
                    366: __STL_BEGIN_NAMESPACE
                    367:
                    368: template <class _T>
                    369: struct _Alloc_traits<_T, gc_alloc >
                    370: {
                    371:   static const bool _S_instanceless = true;
                    372:   typedef simple_alloc<_T, gc_alloc > _Alloc_type;
                    373:   typedef __allocator<_T, gc_alloc > allocator_type;
                    374: };
                    375:
                    376: inline bool operator==(const gc_alloc&,
                    377:                        const gc_alloc&)
                    378: {
                    379:   return true;
                    380: }
                    381:
                    382: inline bool operator!=(const gc_alloc&,
                    383:                        const gc_alloc&)
                    384: {
                    385:   return false;
                    386: }
                    387:
                    388: template <class _T>
                    389: struct _Alloc_traits<_T, single_client_gc_alloc >
                    390: {
                    391:   static const bool _S_instanceless = true;
                    392:   typedef simple_alloc<_T, single_client_gc_alloc > _Alloc_type;
                    393:   typedef __allocator<_T, single_client_gc_alloc > allocator_type;
                    394: };
                    395:
                    396: inline bool operator==(const single_client_gc_alloc&,
                    397:                        const single_client_gc_alloc&)
                    398: {
                    399:   return true;
                    400: }
                    401:
                    402: inline bool operator!=(const single_client_gc_alloc&,
                    403:                        const single_client_gc_alloc&)
                    404: {
                    405:   return false;
                    406: }
                    407:
                    408: template <class _T>
                    409: struct _Alloc_traits<_T, traceable_alloc >
                    410: {
                    411:   static const bool _S_instanceless = true;
                    412:   typedef simple_alloc<_T, traceable_alloc > _Alloc_type;
                    413:   typedef __allocator<_T, traceable_alloc > allocator_type;
                    414: };
                    415:
                    416: inline bool operator==(const traceable_alloc&,
                    417:                        const traceable_alloc&)
                    418: {
                    419:   return true;
                    420: }
                    421:
                    422: inline bool operator!=(const traceable_alloc&,
                    423:                        const traceable_alloc&)
                    424: {
                    425:   return false;
                    426: }
                    427:
                    428: template <class _T>
                    429: struct _Alloc_traits<_T, single_client_traceable_alloc >
                    430: {
                    431:   static const bool _S_instanceless = true;
                    432:   typedef simple_alloc<_T, single_client_traceable_alloc > _Alloc_type;
                    433:   typedef __allocator<_T, single_client_traceable_alloc > allocator_type;
                    434: };
                    435:
                    436: inline bool operator==(const single_client_traceable_alloc&,
                    437:                        const single_client_traceable_alloc&)
                    438: {
                    439:   return true;
                    440: }
                    441:
                    442: inline bool operator!=(const single_client_traceable_alloc&,
                    443:                        const single_client_traceable_alloc&)
                    444: {
                    445:   return false;
                    446: }
                    447:
                    448: __STL_END_NAMESPACE
                    449:
                    450: #endif /* __STL_USE_STD_ALLOCATORS */
                    451:
                    452: #endif /* GC_ALLOC_H */

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>