Return to obj_map.c CVS log

Up to [local] / OpenXM_contrib2 / asir2000 / gc

Annotation of OpenXM_contrib2/asir2000/gc/obj_map.c, Revision 1.1

1.1     ! noro        1: /*
        !             2:  * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers
        !             3:  * Copyright (c) 1991, 1992 by Xerox Corporation.  All rights reserved.
        !             4:  *
        !             5:  * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED
        !             6:  * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.
        !             7:  *
        !             8:  * Permission is hereby granted to use or copy this program
        !             9:  * for any purpose,  provided the above notices are retained on all copies.
        !            10:  * Permission to modify the code and to distribute modified code is granted,
        !            11:  * provided the above notices are retained, and a notice that the code was
        !            12:  * modified is included with the above copyright notice.
        !            13:  */
        !            14: /* Boehm, October 9, 1995 1:09 pm PDT */
        !            15:
        !            16: /* Routines for maintaining maps describing heap block
        !            17:  * layouts for various object sizes.  Allows fast pointer validity checks
        !            18:  * and fast location of object start locations on machines (such as SPARC)
        !            19:  * with slow division.
        !            20:  */
        !            21:
        !            22: # include "gc_priv.h"
        !            23:
        !            24: char * GC_invalid_map = 0;
        !            25:
        !            26: /* Invalidate the object map associated with a block.  Free blocks     */
        !            27: /* are identified by invalid maps.                                     */
        !            28: void GC_invalidate_map(hhdr)
        !            29: hdr *hhdr;
        !            30: {
        !            31:     register int displ;
        !            32:
        !            33:     if (GC_invalid_map == 0) {
        !            34:         GC_invalid_map = GC_scratch_alloc(MAP_SIZE);
        !            35:         if (GC_invalid_map == 0) {
        !            36:             GC_err_printf0(
        !            37:                "Cant initialize GC_invalid_map: insufficient memory\n");
        !            38:             EXIT();
        !            39:         }
        !            40:         for (displ = 0; displ < HBLKSIZE; displ++) {
        !            41:             MAP_ENTRY(GC_invalid_map, displ) = OBJ_INVALID;
        !            42:         }
        !            43:     }
        !            44:     hhdr -> hb_map = GC_invalid_map;
        !            45: }
        !            46:
        !            47: /* Consider pointers that are offset bytes displaced from the beginning */
        !            48: /* of an object to be valid.                                            */
        !            49:
        !            50: # if defined(__STDC__) || defined(__cplusplus)
        !            51:     void GC_register_displacement(GC_word offset)
        !            52: # else
        !            53:     void GC_register_displacement(offset)
        !            54:     GC_word offset;
        !            55: # endif
        !            56: {
        !            57: # ifndef ALL_INTERIOR_POINTERS
        !            58:     DCL_LOCK_STATE;
        !            59:
        !            60:     DISABLE_SIGNALS();
        !            61:     LOCK();
        !            62:     GC_register_displacement_inner(offset);
        !            63:     UNLOCK();
        !            64:     ENABLE_SIGNALS();
        !            65: # endif
        !            66: }
        !            67:
        !            68: void GC_register_displacement_inner(offset)
        !            69: word offset;
        !            70: {
        !            71: # ifndef ALL_INTERIOR_POINTERS
        !            72:     register unsigned i;
        !            73:
        !            74:     if (offset > MAX_OFFSET) {
        !            75:         ABORT("Bad argument to GC_register_displacement");
        !            76:     }
        !            77:     if (!GC_valid_offsets[offset]) {
        !            78:       GC_valid_offsets[offset] = TRUE;
        !            79:       GC_modws_valid_offsets[offset % sizeof(word)] = TRUE;
        !            80:       for (i = 0; i <= MAXOBJSZ; i++) {
        !            81:           if (GC_obj_map[i] != 0) {
        !            82:              if (i == 0) {
        !            83:                GC_obj_map[i][offset + HDR_BYTES] = (char)BYTES_TO_WORDS(offset);
        !            84:              } else {
        !            85:                register unsigned j;
        !            86:                register unsigned lb = WORDS_TO_BYTES(i);
        !            87:
        !            88:                if (offset < lb) {
        !            89:                  for (j = offset + HDR_BYTES; j < HBLKSIZE; j += lb) {
        !            90:                    GC_obj_map[i][j] = (char)BYTES_TO_WORDS(offset);
        !            91:                  }
        !            92:                }
        !            93:              }
        !            94:           }
        !            95:       }
        !            96:     }
        !            97: # endif
        !            98: }
        !            99:
        !           100:
        !           101: /* Add a heap block map for objects of size sz to obj_map.     */
        !           102: /* Return FALSE on failure.                                    */
        !           103: GC_bool GC_add_map_entry(sz)
        !           104: word sz;
        !           105: {
        !           106:     register unsigned obj_start;
        !           107:     register unsigned displ;
        !           108:     register char * new_map;
        !           109:
        !           110:     if (sz > MAXOBJSZ) sz = 0;
        !           111:     if (GC_obj_map[sz] != 0) {
        !           112:         return(TRUE);
        !           113:     }
        !           114:     new_map = GC_scratch_alloc(MAP_SIZE);
        !           115:     if (new_map == 0) return(FALSE);
        !           116: #   ifdef PRINTSTATS
        !           117:         GC_printf1("Adding block map for size %lu\n", (unsigned long)sz);
        !           118: #   endif
        !           119:     for (displ = 0; displ < HBLKSIZE; displ++) {
        !           120:         MAP_ENTRY(new_map,displ) = OBJ_INVALID;
        !           121:     }
        !           122:     if (sz == 0) {
        !           123:         for(displ = 0; displ <= MAX_OFFSET; displ++) {
        !           124:             if (OFFSET_VALID(displ)) {
        !           125:                 MAP_ENTRY(new_map,displ+HDR_BYTES) = BYTES_TO_WORDS(displ);
        !           126:             }
        !           127:         }
        !           128:     } else {
        !           129:         for (obj_start = HDR_BYTES;
        !           130:              obj_start + WORDS_TO_BYTES(sz) <= HBLKSIZE;
        !           131:              obj_start += WORDS_TO_BYTES(sz)) {
        !           132:              for (displ = 0; displ < WORDS_TO_BYTES(sz); displ++) {
        !           133:                  if (OFFSET_VALID(displ)) {
        !           134:                      MAP_ENTRY(new_map, obj_start + displ) =
        !           135:                                                BYTES_TO_WORDS(displ);
        !           136:                  }
        !           137:              }
        !           138:         }
        !           139:     }
        !           140:     GC_obj_map[sz] = new_map;
        !           141:     return(TRUE);
        !           142: }