Subversion Repositories openrisc

/*

 * Copyright 1988, 1989 Hans-J. Boehm, Alan J. Demers

 * Copyright (c) 1991-1994 by Xerox Corporation.  All rights reserved.

 * Copyright (c) 2000 by Hewlett-Packard Company.  All rights reserved.

 *

 * THIS MATERIAL IS PROVIDED AS IS, WITH ABSOLUTELY NO WARRANTY EXPRESSED

 * OR IMPLIED.  ANY USE IS AT YOUR OWN RISK.

 *

 * Permission is hereby granted to use or copy this program

 * for any purpose,  provided the above notices are retained on all copies.

 * Permission to modify the code and to distribute modified code is granted,

 * provided the above notices are retained, and a notice that the code was

 * modified is included with the above copyright notice.

 *

 * This file contains the functions:

 *      ptr_t GC_build_flXXX(h, old_fl)

 *      void GC_new_hblk(n)

 */

/* Boehm, May 19, 1994 2:09 pm PDT */

# include <stdio.h>

# include "private/gc_priv.h"

#ifndef SMALL_CONFIG

/*

 * Build a free list for size 1 objects inside hblk h.  Set the last link to

 * be ofl.  Return a pointer tpo the first free list entry.

 */

ptr_t GC_build_fl1(h, ofl)

struct hblk *h;

ptr_t ofl;

{

    register word * p = h -> hb_body;

    register word * lim = (word *)(h + 1);

    p[0] = (word)ofl;

    p[1] = (word)(p);

    p[2] = (word)(p+1);

    p[3] = (word)(p+2);

    p += 4;

    for (; p < lim; p += 4) {

        p[0] = (word)(p-1);

        p[1] = (word)(p);

        p[2] = (word)(p+1);

        p[3] = (word)(p+2);

    };

    return((ptr_t)(p-1));

}

/* The same for size 2 cleared objects */

ptr_t GC_build_fl_clear2(h, ofl)

struct hblk *h;

ptr_t ofl;

{

    register word * p = h -> hb_body;

    register word * lim = (word *)(h + 1);

    p[0] = (word)ofl;

    p[1] = 0;

    p[2] = (word)p;

    p[3] = 0;

    p += 4;

    for (; p < lim; p += 4) {

        p[0] = (word)(p-2);

        p[1] = 0;

        p[2] = (word)p;

        p[3] = 0;

    };

    return((ptr_t)(p-2));

}

/* The same for size 3 cleared objects */

ptr_t GC_build_fl_clear3(h, ofl)

struct hblk *h;

ptr_t ofl;

{

    register word * p = h -> hb_body;

    register word * lim = (word *)(h + 1) - 2;

    p[0] = (word)ofl;

    p[1] = 0;

    p[2] = 0;

    p += 3;

    for (; p < lim; p += 3) {

        p[0] = (word)(p-3);

        p[1] = 0;

        p[2] = 0;

    };

    return((ptr_t)(p-3));

}

/* The same for size 4 cleared objects */

ptr_t GC_build_fl_clear4(h, ofl)

struct hblk *h;

ptr_t ofl;

{

    register word * p = h -> hb_body;

    register word * lim = (word *)(h + 1);

    p[0] = (word)ofl;

    p[1] = 0;

    p[2] = 0;

    p[3] = 0;

    p += 4;

    for (; p < lim; p += 4) {

        PREFETCH_FOR_WRITE((ptr_t)(p+64));

        p[0] = (word)(p-4);

        p[1] = 0;

        CLEAR_DOUBLE(p+2);

    };

    return((ptr_t)(p-4));

}

/* The same for size 2 uncleared objects */

ptr_t GC_build_fl2(h, ofl)

struct hblk *h;

ptr_t ofl;

{

    register word * p = h -> hb_body;

    register word * lim = (word *)(h + 1);

    p[0] = (word)ofl;

    p[2] = (word)p;

    p += 4;

    for (; p < lim; p += 4) {

        p[0] = (word)(p-2);

        p[2] = (word)p;

    };

    return((ptr_t)(p-2));

}

/* The same for size 4 uncleared objects */

ptr_t GC_build_fl4(h, ofl)

struct hblk *h;

ptr_t ofl;

{

    register word * p = h -> hb_body;

    register word * lim = (word *)(h + 1);

    p[0] = (word)ofl;

    p[4] = (word)p;

    p += 8;

    for (; p < lim; p += 8) {

        PREFETCH_FOR_WRITE((ptr_t)(p+64));

        p[0] = (word)(p-4);

        p[4] = (word)p;

    };

    return((ptr_t)(p-4));

}

#endif /* !SMALL_CONFIG */

/* Build a free list for objects of size sz inside heap block h.        */

/* Clear objects inside h if clear is set.  Add list to the end of      */

/* the free list we build.  Return the new free list.                   */

/* This could be called without the main GC lock, if we ensure that     */

/* there is no concurrent collection which might reclaim objects that   */

/* we have not yet allocated.                                           */

ptr_t GC_build_fl(h, sz, clear, list)

struct hblk *h;

word sz;

GC_bool clear;

ptr_t list;

{

  word *p, *prev;

  word *last_object;            /* points to last object in new hblk    */

  /* Do a few prefetches here, just because its cheap.          */

  /* If we were more serious about it, these should go inside   */

  /* the loops.  But write prefetches usually don't seem to     */

  /* matter much.                                               */

    PREFETCH_FOR_WRITE((ptr_t)h);

    PREFETCH_FOR_WRITE((ptr_t)h + 128);

    PREFETCH_FOR_WRITE((ptr_t)h + 256);

    PREFETCH_FOR_WRITE((ptr_t)h + 378);

  /* Handle small objects sizes more efficiently.  For larger objects   */

  /* the difference is less significant.                                */

#  ifndef SMALL_CONFIG

    switch (sz) {

        case 1: return GC_build_fl1(h, list);

        case 2: if (clear) {

                    return GC_build_fl_clear2(h, list);

                } else {

                    return GC_build_fl2(h, list);

                }

        case 3: if (clear) {

                    return GC_build_fl_clear3(h, list);

                } else {

                    /* It's messy to do better than the default here. */

                    break;

                }

        case 4: if (clear) {

                    return GC_build_fl_clear4(h, list);

                } else {

                    return GC_build_fl4(h, list);

                }

        default:

                break;

    }

#  endif /* !SMALL_CONFIG */

  /* Clear the page if necessary. */

    if (clear) BZERO(h, HBLKSIZE);

  /* Add objects to free list */

    p = &(h -> hb_body[sz]);    /* second object in *h  */

    prev = &(h -> hb_body[0]);           /* One object behind p  */

    last_object = (word *)((char *)h + HBLKSIZE);

    last_object -= sz;

                            /* Last place for last object to start */

  /* make a list of all objects in *h with head as last object */

    while (p <= last_object) {

      /* current object's link points to last object */

        obj_link(p) = (ptr_t)prev;

        prev = p;

        p += sz;

    }

    p -= sz;                    /* p now points to last object */

  /*

   * put p (which is now head of list of objects in *h) as first

   * pointer in the appropriate free list for this size.

   */

      obj_link(h -> hb_body) = list;

      return ((ptr_t)p);

}

/*

 * Allocate a new heapblock for small objects of size n.

 * Add all of the heapblock's objects to the free list for objects

 * of that size.

 * Set all mark bits if objects are uncollectable.

 * Will fail to do anything if we are out of memory.

 */

void GC_new_hblk(sz, kind)

register word sz;

int kind;

{

    register struct hblk *h;    /* the new heap block                   */

    register GC_bool clear = GC_obj_kinds[kind].ok_init;

#   ifdef PRINTSTATS

        if ((sizeof (struct hblk)) > HBLKSIZE) {

            ABORT("HBLK SZ inconsistency");

        }

#   endif

  if (GC_debugging_started) clear = TRUE;

  /* Allocate a new heap block */

    h = GC_allochblk(sz, kind, 0);

    if (h == 0) return;

  /* Mark all objects if appropriate. */

      if (IS_UNCOLLECTABLE(kind)) GC_set_hdr_marks(HDR(h));

  /* Build the free list */

      GC_obj_kinds[kind].ok_freelist[sz] =

        GC_build_fl(h, sz, clear, GC_obj_kinds[kind].ok_freelist[sz]);

}