aboutsummaryrefslogtreecommitdiffstats
path: root/gc/new_hblk.c
diff options
context:
space:
mode:
Diffstat (limited to 'gc/new_hblk.c')
-rw-r--r--gc/new_hblk.c263
1 files changed, 0 insertions, 263 deletions
diff --git a/gc/new_hblk.c b/gc/new_hblk.c
deleted file mode 100644
index 1aa2c7a..0000000
--- a/gc/new_hblk.c
+++ /dev/null
@@ -1,263 +0,0 @@
-/*
- * 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(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(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((char *)h);
- PREFETCH_FOR_WRITE((char *)h + 128);
- PREFETCH_FOR_WRITE((char *)h + 256);
- PREFETCH_FOR_WRITE((char *)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]);
-}
-
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-23 14:31:40 +0000