Return to pcr_interface.c CVS log

Up to [local] / OpenXM_contrib2 / asir2000 / gc

Annotation of OpenXM_contrib2/asir2000/gc/pcr_interface.c, Revision 1.4

1.1       noro        1: /*
                      2:  * Copyright (c) 1991-1994 by Xerox Corporation.  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:  */
1.2       noro       13: # include "private/gc_priv.h"
1.1       noro       14:
                     15: # ifdef PCR
                     16: /*
                     17:  * Note that POSIX PCR requires an ANSI C compiler.  Hence we are allowed
                     18:  * to make the same assumption here.
                     19:  * We wrap all of the allocator functions to avoid questions of
                     20:  * compatibility between the prototyped and nonprototyped versions of the f
                     21:  */
                     22: # include "config/PCR_StdTypes.h"
                     23: # include "mm/PCR_MM.h"
                     24: # include <errno.h>
                     25:
                     26: # define MY_MAGIC 17L
                     27: # define MY_DEBUGMAGIC 42L
                     28:
                     29: void * GC_AllocProc(size_t size, PCR_Bool ptrFree, PCR_Bool clear )
                     30: {
                     31:     if (ptrFree) {
                     32:         void * result = (void *)GC_malloc_atomic(size);
                     33:         if (clear && result != 0) BZERO(result, size);
                     34:         return(result);
                     35:     } else {
                     36:         return((void *)GC_malloc(size));
                     37:     }
                     38: }
                     39:
                     40: void * GC_DebugAllocProc(size_t size, PCR_Bool ptrFree, PCR_Bool clear )
                     41: {
                     42:     if (ptrFree) {
                     43:         void * result = (void *)GC_debug_malloc_atomic(size, __FILE__,
                     44:                                                             __LINE__);
                     45:         if (clear && result != 0) BZERO(result, size);
                     46:         return(result);
                     47:     } else {
                     48:         return((void *)GC_debug_malloc(size, __FILE__, __LINE__));
                     49:     }
                     50: }
                     51:
                     52: # define GC_ReallocProc GC_realloc
                     53: void * GC_DebugReallocProc(void * old_object, size_t new_size_in_bytes)
                     54: {
                     55:     return(GC_debug_realloc(old_object, new_size_in_bytes, __FILE__, __LINE__));
                     56: }
                     57:
                     58: # define GC_FreeProc GC_free
                     59: # define GC_DebugFreeProc GC_debug_free
                     60:
                     61: typedef struct {
                     62:   PCR_ERes (*ed_proc)(void *p, size_t size, PCR_Any data);
                     63:   GC_bool ed_pointerfree;
                     64:   PCR_ERes ed_fail_code;
                     65:   PCR_Any ed_client_data;
                     66: } enumerate_data;
                     67:
                     68: void GC_enumerate_block(h, ed)
                     69: register struct hblk *h;
                     70: enumerate_data * ed;
                     71: {
                     72:     register hdr * hhdr;
                     73:     register int sz;
                     74:     word *p;
                     75:     word * lim;
                     76:
                     77:     hhdr = HDR(h);
                     78:     sz = hhdr -> hb_sz;
                     79:     if (sz >= 0 && ed -> ed_pointerfree
                     80:        || sz <= 0 && !(ed -> ed_pointerfree)) return;
                     81:     if (sz < 0) sz = -sz;
                     82:     lim = (word *)(h+1) - sz;
                     83:     p = (word *)h;
                     84:     do {
                     85:         if (PCR_ERes_IsErr(ed -> ed_fail_code)) return;
                     86:         ed -> ed_fail_code =
                     87:             (*(ed -> ed_proc))(p, WORDS_TO_BYTES(sz), ed -> ed_client_data);
                     88:         p+= sz;
                     89:     } while (p <= lim);
                     90: }
                     91:
                     92: struct PCR_MM_ProcsRep * GC_old_allocator = 0;
                     93:
                     94: PCR_ERes GC_EnumerateProc(
                     95:     PCR_Bool ptrFree,
                     96:     PCR_ERes (*proc)(void *p, size_t size, PCR_Any data),
                     97:     PCR_Any data
                     98: )
                     99: {
                    100:     enumerate_data ed;
                    101:
                    102:     ed.ed_proc = proc;
                    103:     ed.ed_pointerfree = ptrFree;
                    104:     ed.ed_fail_code = PCR_ERes_okay;
                    105:     ed.ed_client_data = data;
                    106:     GC_apply_to_all_blocks(GC_enumerate_block, &ed);
                    107:     if (ed.ed_fail_code != PCR_ERes_okay) {
                    108:         return(ed.ed_fail_code);
                    109:     } else {
                    110:        /* Also enumerate objects allocated by my predecessors */
                    111:        return((*(GC_old_allocator->mmp_enumerate))(ptrFree, proc, data));
                    112:     }
                    113: }
                    114:
                    115: void GC_DummyFreeProc(void *p) {}
                    116:
                    117: void GC_DummyShutdownProc(void) {}
                    118:
                    119: struct PCR_MM_ProcsRep GC_Rep = {
                    120:        MY_MAGIC,
                    121:        GC_AllocProc,
                    122:        GC_ReallocProc,
                    123:        GC_DummyFreeProc,       /* mmp_free */
                    124:        GC_FreeProc,            /* mmp_unsafeFree */
                    125:        GC_EnumerateProc,
                    126:        GC_DummyShutdownProc    /* mmp_shutdown */
                    127: };
                    128:
                    129: struct PCR_MM_ProcsRep GC_DebugRep = {
                    130:        MY_DEBUGMAGIC,
                    131:        GC_DebugAllocProc,
                    132:        GC_DebugReallocProc,
                    133:        GC_DummyFreeProc,       /* mmp_free */
                    134:        GC_DebugFreeProc,               /* mmp_unsafeFree */
                    135:        GC_EnumerateProc,
                    136:        GC_DummyShutdownProc    /* mmp_shutdown */
                    137: };
                    138:
                    139: GC_bool GC_use_debug = 0;
                    140:
                    141: void GC_pcr_install()
                    142: {
                    143:     PCR_MM_Install((GC_use_debug? &GC_DebugRep : &GC_Rep), &GC_old_allocator);
                    144: }
                    145:
                    146: PCR_ERes
                    147: PCR_GC_Setup(void)
                    148: {
                    149:     return PCR_ERes_okay;
                    150: }
                    151:
                    152: PCR_ERes
                    153: PCR_GC_Run(void)
                    154: {
                    155:
                    156:     if( !PCR_Base_TestPCRArg("-nogc") ) {
                    157:         GC_quiet = ( PCR_Base_TestPCRArg("-gctrace") ? 0 : 1 );
                    158:         GC_use_debug = (GC_bool)PCR_Base_TestPCRArg("-debug_alloc");
                    159:         GC_init();
                    160:         if( !PCR_Base_TestPCRArg("-nogc_incremental") ) {
                    161:             /*
                    162:              * awful hack to test whether VD is implemented ...
                    163:              */
                    164:             if( PCR_VD_Start( 0, NIL, 0) != PCR_ERes_FromErr(ENOSYS) ) {
                    165:                GC_enable_incremental();
                    166:            }
                    167:        }
                    168:     }
                    169:     return PCR_ERes_okay;
1.2       noro      170: }
                    171:
                    172: void GC_push_thread_structures(void)
                    173: {
                    174:     /* PCR doesn't work unless static roots are pushed.  Can't get here. */
                    175:     ABORT("In GC_push_thread_structures()");
1.1       noro      176: }
                    177:
                    178: # endif