Subversion Repositories scarts

/*

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

 * Copyright (c) 1991-1994 by Xerox Corporation.  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.

 */

/* Boehm, July 31, 1995 5:02 pm PDT */

#include "private/gc_priv.h"

# ifdef STUBBORN_ALLOC

/* Stubborn object (hard to change, nearly immutable) allocation. */

extern ptr_t GC_clear_stack();  /* in misc.c, behaves like identity */

#define GENERAL_MALLOC(lb,k) \

    (GC_PTR)GC_clear_stack(GC_generic_malloc((word)lb, k))

/* Data structure representing immutable objects that   */

/* are still being initialized.                         */

/* This is a bit baroque in order to avoid acquiring    */

/* the lock twice for a typical allocation.             */

GC_PTR * GC_changing_list_start;

void GC_push_stubborn_structures GC_PROTO((void))

{

    GC_push_all((ptr_t)(&GC_changing_list_start),

                (ptr_t)(&GC_changing_list_start) + sizeof(GC_PTR *));

}

# ifdef THREADS

  VOLATILE GC_PTR * VOLATILE GC_changing_list_current;

# else

  GC_PTR * GC_changing_list_current;

# endif

        /* Points at last added element.  Also (ab)used for             */

        /* synchronization.  Updates and reads are assumed atomic.      */

GC_PTR * GC_changing_list_limit;

        /* Points at the last word of the buffer, which is always 0     */

        /* All entries in (GC_changing_list_current,                    */

        /* GC_changing_list_limit] are 0                                */

void GC_stubborn_init()

{

#   define INIT_SIZE 10

    GC_changing_list_start = (GC_PTR *)

                        GC_INTERNAL_MALLOC(

                                (word)(INIT_SIZE * sizeof(GC_PTR)),

                                PTRFREE);

    BZERO(GC_changing_list_start,

          INIT_SIZE * sizeof(GC_PTR));

    if (GC_changing_list_start == 0) {

        GC_err_printf0("Insufficient space to start up\n");

        ABORT("GC_stubborn_init: put of space");

    }

    GC_changing_list_current = GC_changing_list_start;

    GC_changing_list_limit = GC_changing_list_start + INIT_SIZE - 1;

    * GC_changing_list_limit = 0;

}

/* Compact and possibly grow GC_uninit_list.  The old copy is           */

/* left alone.  Lock must be held.                                      */

/* When called GC_changing_list_current == GC_changing_list_limit       */

/* which is one past the current element.                               */

/* When we finish GC_changing_list_current again points one past last   */

/* element.                                                             */

/* Invariant while this is running: GC_changing_list_current            */

/* points at a word containing 0.                                       */

/* Returns FALSE on failure.                                            */

GC_bool GC_compact_changing_list()

{

    register GC_PTR *p, *q;

    register word count = 0;

    word old_size = (char **)GC_changing_list_limit

                    - (char **)GC_changing_list_start+1;

                    /* The casts are needed as a workaround for an Amiga bug */

    register word new_size = old_size;

    GC_PTR * new_list;

    for (p = GC_changing_list_start; p < GC_changing_list_limit; p++) {

        if (*p != 0) count++;

    }

    if (2 * count > old_size) new_size = 2 * count;

    new_list = (GC_PTR *)

                GC_INTERNAL_MALLOC(

                                new_size * sizeof(GC_PTR), PTRFREE);

                /* PTRFREE is a lie.  But we don't want the collector to  */

                /* consider these.  We do want the list itself to be      */

                /* collectable.                                           */

    if (new_list == 0) return(FALSE);

    BZERO(new_list, new_size * sizeof(GC_PTR));

    q = new_list;

    for (p = GC_changing_list_start; p < GC_changing_list_limit; p++) {

        if (*p != 0) *q++ = *p;

    }

    GC_changing_list_start = new_list;

    GC_changing_list_limit = new_list + new_size - 1;

    GC_changing_list_current = q;

    return(TRUE);

}

/* Add p to changing list.  Clear p on failure. */

# define ADD_CHANGING(p) \

        {       \

            register struct hblk * h = HBLKPTR(p);      \

            register word index = PHT_HASH(h);  \

            \

            set_pht_entry_from_index(GC_changed_pages, index);  \

        }       \

        if (*GC_changing_list_current != 0 \

            && ++GC_changing_list_current == GC_changing_list_limit) { \

            if (!GC_compact_changing_list()) (p) = 0; \

        } \

        *GC_changing_list_current = p;

void GC_change_stubborn(p)

GC_PTR p;

{

    DCL_LOCK_STATE;

    DISABLE_SIGNALS();

    LOCK();

    ADD_CHANGING(p);

    UNLOCK();

    ENABLE_SIGNALS();

}

void GC_end_stubborn_change(p)

GC_PTR p;

{

#   ifdef THREADS

      register VOLATILE GC_PTR * my_current = GC_changing_list_current;

#   else

      register GC_PTR * my_current = GC_changing_list_current;

#   endif

    register GC_bool tried_quick;

    DCL_LOCK_STATE;

    if (*my_current == p) {

        /* Hopefully the normal case.                                   */

        /* Compaction could not have been running when we started.      */

        *my_current = 0;

#       ifdef THREADS

          if (my_current == GC_changing_list_current) {

            /* Compaction can't have run in the interim.        */

            /* We got away with the quick and dirty approach.   */

            return;

          }

          tried_quick = TRUE;

#       else

          return;

#       endif

    } else {

        tried_quick = FALSE;

    }

    DISABLE_SIGNALS();

    LOCK();

    my_current = GC_changing_list_current;

    for (; my_current >= GC_changing_list_start; my_current--) {

        if (*my_current == p) {

            *my_current = 0;

            UNLOCK();

            ENABLE_SIGNALS();

            return;

        }

    }

    if (!tried_quick) {

        GC_err_printf1("Bad arg to GC_end_stubborn_change: 0x%lx\n",

                       (unsigned long)p);

        ABORT("Bad arg to GC_end_stubborn_change");

    }

    UNLOCK();

    ENABLE_SIGNALS();

}

/* Allocate lb bytes of composite (pointerful) data     */

/* No pointer fields may be changed after a call to     */

/* GC_end_stubborn_change(p) where p is the value       */

/* returned by GC_malloc_stubborn.                      */

# ifdef __STDC__

    GC_PTR GC_malloc_stubborn(size_t lb)

# else

    GC_PTR GC_malloc_stubborn(lb)

    size_t lb;

# endif

{

register ptr_t op;

register ptr_t *opp;

register word lw;

ptr_t result;

DCL_LOCK_STATE;

    if( SMALL_OBJ(lb) ) {

#       ifdef MERGE_SIZES

          lw = GC_size_map[lb];

#       else

          lw = ALIGNED_WORDS(lb);

#       endif

        opp = &(GC_sobjfreelist[lw]);

        FASTLOCK();

        if( !FASTLOCK_SUCCEEDED() || (op = *opp) == 0 ) {

            FASTUNLOCK();

            result = GC_generic_malloc((word)lb, STUBBORN);

            goto record;

        }

        *opp = obj_link(op);

        obj_link(op) = 0;

        GC_words_allocd += lw;

        result = (GC_PTR) op;

        ADD_CHANGING(result);

        FASTUNLOCK();

        return((GC_PTR)result);

   } else {

       result = (GC_PTR)

                GC_generic_malloc((word)lb, STUBBORN);

   }

record:

   DISABLE_SIGNALS();

   LOCK();

   ADD_CHANGING(result);

   UNLOCK();

   ENABLE_SIGNALS();

   return((GC_PTR)GC_clear_stack(result));

}

/* Functions analogous to GC_read_dirty and GC_page_was_dirty.  */

/* Report pages on which stubborn objects were changed.         */

void GC_read_changed()

{

    register GC_PTR * p = GC_changing_list_start;

    register GC_PTR q;

    register struct hblk * h;

    register word index;

    if (p == 0) /* initializing */ return;

    BCOPY(GC_changed_pages, GC_prev_changed_pages,

          (sizeof GC_changed_pages));

    BZERO(GC_changed_pages, (sizeof GC_changed_pages));

    for (; p <= GC_changing_list_current; p++) {

        if ((q = *p) != 0) {

            h = HBLKPTR(q);

            index = PHT_HASH(h);

            set_pht_entry_from_index(GC_changed_pages, index);

        }

    }

}

GC_bool GC_page_was_changed(h)

struct hblk * h;

{

    register word index = PHT_HASH(h);

    return(get_pht_entry_from_index(GC_prev_changed_pages, index));

}

/* Remove unreachable entries from changed list. Should only be */

/* called with mark bits consistent and lock held.              */

void GC_clean_changing_list()

{

    register GC_PTR * p = GC_changing_list_start;

    register GC_PTR q;

    register ptr_t r;

    register unsigned long count = 0;

    register unsigned long dropped_count = 0;

    if (p == 0) /* initializing */ return;

    for (; p <= GC_changing_list_current; p++) {

        if ((q = *p) != 0) {

            count++;

            r = (ptr_t)GC_base(q);

            if (r == 0 || !GC_is_marked(r)) {

                *p = 0;

                dropped_count++;

            }

        }

    }

#   ifdef PRINTSTATS

      if (count > 0) {

        GC_printf2("%lu entries in changing list: reclaimed %lu\n",

                  (unsigned long)count, (unsigned long)dropped_count);

      }

#   endif

}

#else /* !STUBBORN_ALLOC */

# ifdef __STDC__

    GC_PTR GC_malloc_stubborn(size_t lb)

# else

    GC_PTR GC_malloc_stubborn(lb)

    size_t lb;

# endif

{

    return(GC_malloc(lb));

}

/*ARGSUSED*/

void GC_end_stubborn_change(p)

GC_PTR p;

{

}

/*ARGSUSED*/

void GC_change_stubborn(p)

GC_PTR p;

{

}

void GC_push_stubborn_structures GC_PROTO((void))

{

}

#endif