Remove stale code for hybrid heap and incremental GC

The hybrid heap emulator was last working in the non-SMP R11B
run-time system. When the constant pools were introduced in R12B,
the hybrid heap emulator was not updated to handle them.

At this point, the harm from reduced readability of the code is
greater than any potential usefulness of keeping the code.

1 files changed, 0 insertions, 433 deletions

diff --git a/erts/emulator/beam/copy.c b/erts/emulator/beam/copy.c
index d7345c2f54..36eda04de2 100644
--- a/erts/emulator/beam/copy.c
+++ b/erts/emulator/beam/copy.c
@@ -26,30 +26,13 @@
 #include "global.h"
 #include "erl_process.h"
 #include "erl_gc.h"
-#include "erl_nmgc.h"
 #include "big.h"
 #include "erl_binary.h"
 #include "erl_bits.h"
 #include "dtrace-wrapper.h"
 
-#ifdef HYBRID
-MA_STACK_DECLARE(src);
-MA_STACK_DECLARE(dst);
-MA_STACK_DECLARE(offset);
-#endif
-
 static void move_one_frag(Eterm** hpp, Eterm* src, Uint src_sz, ErlOffHeap*);
 
-void
-init_copy(void)
-{
-#ifdef HYBRID
-    MA_STACK_ALLOC(src);
-    MA_STACK_ALLOC(dst);
-    MA_STACK_ALLOC(offset);
-#endif
-}
-
 /*
  *  Copy object "obj" to process p.
  */
@@ -432,12 +415,10 @@ Eterm copy_struct(Eterm obj, Uint sz, Eterm** hpp, ErlOffHeap* off_heap)
 		    while (i--)  {
 			*htop++ = *objp++;
 		    }
-#ifndef HYBRID /* FIND ME! */
 		    funp = (ErlFunThing *) tp;
 		    funp->next = off_heap->first;
 		    off_heap->first = (struct erl_off_heap_header*) funp;
 		    erts_refc_inc(&funp->fe->refc, 2);
-#endif
 		    *argp = make_fun_rel(tp, dst_base);
 		}
 		break;
@@ -500,420 +481,6 @@ Eterm copy_struct(Eterm obj, Uint sz, Eterm** hpp, ErlOffHeap* off_heap)
     return res;
 }
 
-#ifdef HYBRID
-
-#ifdef BM_MESSAGE_SIZES
-#  define BM_ADD(var,val) (var) += (val);
-#else
-#  define BM_ADD(var,val)
-#endif
-
-#ifdef DEBUG
-#  define CLEARMEM(PTR,SIZE) memset(PTR,0,SIZE*sizeof(Eterm))
-#else
-#  define CLEARMEM(PTR,SIZE)
-#endif
-
-#ifdef INCREMENTAL
-#define GlobalAlloc(p, need, hp)                                        \
-do {                                                                    \
-    Uint n = (need);                                                    \
-    BM_ADD(words_copied,n);                                             \
-    BM_SWAP_TIMER(copy,system);                                         \
-    /* If a new collection cycle is started during copy, the message *  \
-     * will end up in the old generation and all allocations         *  \
-     * thereafter must go directly into the old generation.          */ \
-    if (alloc_old) {                                                    \
-        erts_incremental_gc((p),n,&dest,1);                             \
-        (hp) = erts_inc_alloc(n);                                       \
-    } else {                                                            \
-        (hp) = IncAlloc((p),n,&dest,1);                                 \
-        if (ma_gc_flags & GC_CYCLE_START) {                             \
-            alloc_old = 1;                                              \
-            global_htop = global_heap;                                  \
-            (hp) = erts_inc_alloc(n);                                   \
-        }                                                               \
-    }                                                                   \
-    CLEARMEM((hp),(n));                                                 \
-    BM_SWAP_TIMER(system,copy);                                         \
-} while(0)
-
-#else /* no INCREMELNTAL */
-
-#define GlobalAlloc(p, need, hp)                                        \
-do {                                                                    \
-    Uint n = (need);                                                    \
-    total_need += n;                                                    \
-    if (total_need >= global_heap_sz)                                   \
-        erl_exit(ERTS_ABORT_EXIT, "Copying a message (%d words) larger than the nursery simply won't work...\n", total_need); \
-    if (global_hend - n < global_htop) {                                \
-        BM_SWAP_TIMER(copy,system);                                     \
-        erts_global_garbage_collect((p),total_need,NULL,0);             \
-        BM_SWAP_TIMER(system,copy);                                     \
-        total_need = 0;                                                 \
-        ma_src_top = 0;                                                 \
-        ma_dst_top = 0;                                                 \
-        ma_offset_top = 0;                                              \
-        goto copy_start;                                                \
-    }                                                                   \
-    (hp) = global_htop;                                                 \
-    global_htop += n;                                                   \
-    BM_ADD(words_copied,n);                                             \
-} while(0)
-#endif /* INCREMENTAL */
-
-/* Copy a message to the message area. */
-Eterm copy_struct_lazy(Process *from, Eterm orig, Uint offs)
-{
-    Eterm obj;
-    Eterm dest;
-#ifdef INCREMENTAL
-    int alloc_old = 0;
-#else
-    int total_need = 0;
-#endif
-
-    VERBOSE(DEBUG_MESSAGES,
-            ("COPY START; %T is sending a message @ 0x%016x\n%T\n",
-             from->id, orig, orig));
-
-#ifndef INCREMENTAL
- copy_start:
-#endif
-    MA_STACK_PUSH(src,orig);
-    MA_STACK_PUSH(dst,&dest);
-    MA_STACK_PUSH(offset,offs);
-
-    while (ma_src_top > 0) {
-        obj = MA_STACK_POP(src);
-
-        /* copy_struct_lazy should never be called with something that
-         * do not need to be copied. Within the loop, nothing that do
-         * not need copying should be placed in the src-stack.
-         */
-        ASSERT(!NO_COPY(obj));
-
-        switch (primary_tag(obj)) {
-        case TAG_PRIMARY_LIST: {
-            Eterm *hp;
-            Eterm *objp;
-
-            GlobalAlloc(from,2,hp);
-            objp = list_val(obj);
-
-            MA_STACK_UPDATE(dst,MA_STACK_POP(offset),make_list(hp));
-            MA_STACK_POP(dst);
-
-            /* TODO: Byt ordningen nedan så att CDR pushas först. */
-
-            if (NO_COPY(*objp)) {
-                hp[0] = *objp;
-#ifdef INCREMENTAL
-                if (ptr_within(ptr_val(*objp),inc_fromspc,inc_fromend))
-                    INC_STORE(gray,hp,2);
-#endif
-            } else {
-                MA_STACK_PUSH(src,*objp);
-                MA_STACK_PUSH(dst,hp);
-                MA_STACK_PUSH(offset,0);
-            }
-
-            objp++;
-
-            if (NO_COPY(*objp)) {
-                hp[1] = *objp;
-#ifdef INCREMENTAL
-                if (ptr_within(ptr_val(*objp),inc_fromspc,inc_fromend))
-                    INC_STORE(gray,hp,2);
-#endif
-            }
-            else {
-                MA_STACK_PUSH(src,*objp);
-                MA_STACK_PUSH(dst,hp);
-                MA_STACK_PUSH(offset,1);
-            }
-            continue;
-        }
-
-        case TAG_PRIMARY_BOXED: {
-            Eterm *objp = boxed_val(obj);
-
-            switch (*objp & _TAG_HEADER_MASK) {
-            case ARITYVAL_SUBTAG: {
-                Uint ari = arityval(*objp);
-                Uint i;
-                Eterm *hp;
-                GlobalAlloc(from,ari + 1,hp);
-                /* A GC above might invalidate the value of objp */
-                objp = boxed_val(obj);
-                MA_STACK_UPDATE(dst,MA_STACK_POP(offset),make_tuple(hp));
-                MA_STACK_POP(dst);
-                *hp = *objp++;
-                for (i = 1; i <= ari; i++) {
-                    switch (primary_tag(*objp)) {
-                    case TAG_PRIMARY_LIST:
-                    case TAG_PRIMARY_BOXED:
-                        if (NO_COPY(*objp)) {
-                            hp[i] = *objp;
-#ifdef INCREMENTAL
-                            if (ptr_within(ptr_val(*objp),
-                                           inc_fromspc,inc_fromend))
-                                INC_STORE(gray,hp,BOXED_NEED(hp,*hp));
-#endif
-                            objp++;
-                        } else {
-                            MA_STACK_PUSH(src,*objp++);
-                            MA_STACK_PUSH(dst,hp);
-                            MA_STACK_PUSH(offset,i);
-                        }
-                        break;
-                    default:
-                        hp[i] = *objp++;
-                    }
-                }
-                continue;
-            }
-
-            case REFC_BINARY_SUBTAG: {
-                ProcBin *pb;
-                Uint i = thing_arityval(*objp) + 1;
-                Eterm *hp;
-                GlobalAlloc(from,i,hp);
-                /* A GC above might invalidate the value of objp */
-                objp = boxed_val(obj);
-                MA_STACK_UPDATE(dst,MA_STACK_POP(offset),make_binary(hp));
-                MA_STACK_POP(dst);
-                pb = (ProcBin*) hp;
-                while (i--) {
-                    *hp++ = *objp++;
-                }
-                erts_refc_inc(&pb->val->refc, 2);
-                pb->next = erts_global_offheap.first;
-                erts_global_offheap.first = pb;
-		OH_OVERHEAD(off_heap, pb->size / sizeof(Eterm));
-                continue;
-            }
-
-            case FUN_SUBTAG: {
-                ErlFunThing *funp = (ErlFunThing*) objp;
-                Uint i = thing_arityval(*objp) + 1;
-                Uint j = i + 1 + funp->num_free;
-                Uint k = i;
-                Eterm *hp, *hp_start;
-                GlobalAlloc(from,j,hp);
-                /* A GC above might invalidate the value of objp */
-                objp = boxed_val(obj);
-                hp_start = hp;
-                MA_STACK_UPDATE(dst,MA_STACK_POP(offset),make_fun(hp));
-                MA_STACK_POP(dst);
-                funp = (ErlFunThing*) hp;
-                while (i--) {
-                    *hp++ = *objp++;
-                }
-#ifndef HYBRID /* FIND ME! */
-                funp->next = erts_global_offheap.first;
-                erts_global_offheap.first = funp;
-                erts_refc_inc(&funp->fe->refc, 2);
-#endif
-                for (i = k; i < j; i++) {
-                    switch (primary_tag(*objp)) {
-                    case TAG_PRIMARY_LIST:
-                    case TAG_PRIMARY_BOXED:
-                        if (NO_COPY(*objp)) {
-#ifdef INCREMENTAL
-                            if (ptr_within(ptr_val(*objp),
-                                           inc_fromspc,inc_fromend))
-                                INC_STORE(gray,hp,BOXED_NEED(hp,*hp));
-#endif
-                            *hp++ = *objp++;
-                        } else {
-                            MA_STACK_PUSH(src,*objp++);
-                            MA_STACK_PUSH(dst,hp_start);
-                            MA_STACK_PUSH(offset,i);
-                            hp++;
-                        }
-                        break;
-                    default:
-                        *hp++ = *objp++;
-                    }
-                }
-                continue;
-            }
-
-            case EXTERNAL_PID_SUBTAG:
-            case EXTERNAL_PORT_SUBTAG:
-            case EXTERNAL_REF_SUBTAG: {
-                ExternalThing *etp;
-                Uint i =  thing_arityval(*objp) + 1;
-                Eterm *hp;
-                GlobalAlloc(from,i,hp);
-                /* A GC above might invalidate the value of objp */
-                objp = boxed_val(obj);
-                MA_STACK_UPDATE(dst,MA_STACK_POP(offset),make_external(hp));
-                MA_STACK_POP(dst);
-                etp = (ExternalThing*) hp;
-                while (i--)  {
-                    *hp++ = *objp++;
-                }
-
-                etp->next = erts_global_offheap.first;
-                erts_global_offheap.first = etp;
-		erts_refc_inc(&etp->node->refc, 2);
-                continue;
-            }
-
-            case SUB_BINARY_SUBTAG: {
-                ErlSubBin *sb = (ErlSubBin *) objp;
-		Eterm *hp;
-		Eterm res_binary;
-                Eterm real_bin = sb->orig;
-                Uint bit_offset = sb->bitoffs;
-		Uint bit_size = sb -> bitsize;
-		Uint sub_offset = sb->offs;
-                size_t size = sb->size;
-		Uint extra_bytes;
-		Uint real_size;
-		Uint sub_binary_heapneed;
-		if ((bit_size + bit_offset) > 8) {
-		    extra_bytes = 2;
-		    sub_binary_heapneed = ERL_SUB_BIN_SIZE;
-		} else if ((bit_size + bit_offset) > 0) {
-		    extra_bytes = 1;
-		    sub_binary_heapneed = ERL_SUB_BIN_SIZE;
-		} else {
-		    extra_bytes = 0;
-		    sub_binary_heapneed = 0;
-		}
-		
-		real_size = size+extra_bytes;
-                objp = binary_val(real_bin);
-                if (thing_subtag(*objp) == HEAP_BINARY_SUBTAG) {
-                    ErlHeapBin *from_bin;
-                    ErlHeapBin *to_bin;
-                    Uint i = heap_bin_size(real_size);
-                    GlobalAlloc(from,i+sub_binary_heapneed,hp);
-                    from_bin = (ErlHeapBin *) objp;
-                    to_bin = (ErlHeapBin *) hp;
-                    to_bin->thing_word = header_heap_bin(real_size);
-                    to_bin->size = real_size;
-                    sys_memcpy(to_bin->data, ((byte *)from_bin->data) +
-                               sub_offset, real_size);
-		    res_binary = make_binary(to_bin);
-		    hp += i;
-                } else {
-                    ProcBin *from_bin;
-                    ProcBin *to_bin;
-                    
-                    ASSERT(thing_subtag(*objp) == REFC_BINARY_SUBTAG);
-		    from_bin = (ProcBin *) objp;
-		    erts_refc_inc(&from_bin->val->refc, 2);
-                    GlobalAlloc(from,PROC_BIN_SIZE+sub_binary_heapneed,hp);
-                    to_bin = (ProcBin *) hp;
-                    to_bin->thing_word = HEADER_PROC_BIN;
-                    to_bin->size = real_size;
-                    to_bin->val = from_bin->val;
-                    to_bin->bytes = from_bin->bytes + sub_offset;
-                    to_bin->next = erts_global_offheap.first;
-                    erts_global_offheap.first = to_bin;
-		    OH_OVERHEAD(&erts_global_offheap, to_bin->size / sizeof(Eterm));
-		    res_binary=make_binary(to_bin);
-		    hp += PROC_BIN_SIZE;
-                }
-		if (extra_bytes != 0) {
-		    ErlSubBin* res;
-		    res = (ErlSubBin *) hp;
-		    res->thing_word = HEADER_SUB_BIN;
-		    res->size = size;
-		    res->bitsize = bit_size;
-		    res->bitoffs = bit_offset;
-		    res->offs = 0;
-		    res->is_writable = 0;
-		    res->orig = res_binary;
-		    res_binary = make_binary(hp);
-		}
-		MA_STACK_UPDATE(dst,MA_STACK_POP(offset),res_binary);
-		MA_STACK_POP(dst);
-                continue;
-            }
-
-	    case BIN_MATCHSTATE_SUBTAG:
-		erl_exit(ERTS_ABORT_EXIT,
-			 "copy_struct_lazy: matchstate term not allowed");
-
-            default: {
-                Uint size = thing_arityval(*objp) + 1;
-                Eterm *hp;
-                GlobalAlloc(from,size,hp);
-                /* A GC above might invalidate the value of objp */
-                objp = boxed_val(obj);
-                MA_STACK_UPDATE(dst,MA_STACK_POP(offset),make_boxed(hp));
-                MA_STACK_POP(dst);
-                while (size--) {
-                    *hp++ = *objp++;
-                }
-                continue;
-            }
-            }
-            continue;
-        }
-
-        case TAG_PRIMARY_HEADER:
-        ASSERT((obj & _TAG_HEADER_MASK) == ARITYVAL_SUBTAG);
-        {
-            Eterm *objp = &obj;
-            Uint ari = arityval(obj);
-            Uint i;
-            Eterm *hp;
-            GlobalAlloc(from,ari + 1,hp);
-            MA_STACK_UPDATE(dst,MA_STACK_POP(offset),make_tuple(hp));
-            MA_STACK_POP(dst);
-            *hp = *objp++;
-            for (i = 1; i <= ari; i++) {
-                switch (primary_tag(*objp)) {
-                case TAG_PRIMARY_LIST:
-                case TAG_PRIMARY_BOXED:
-                    if (NO_COPY(*objp)) {
-#ifdef INCREMENTAL
-                        if (ptr_within(ptr_val(*objp),inc_fromspc,inc_fromend))
-                            INC_STORE(gray,hp,ari + 1);
-#endif
-                        hp[i] = *objp++;
-                    } else {
-                        MA_STACK_PUSH(src,*objp++);
-                        MA_STACK_PUSH(dst,hp);
-                        MA_STACK_PUSH(offset,i);
-                    }
-                    break;
-                default:
-                    hp[i] = *objp++;
-                }
-            }
-            continue;
-        }
-
-        default:
-            erl_exit(ERTS_ABORT_EXIT,
-		     "%s, line %d: Internal error in copy_struct_lazy: 0x%08x\n",
-                     __FILE__, __LINE__,obj);
-        }
-    }
-
-    VERBOSE(DEBUG_MESSAGES,
-            ("Copy allocated @ 0x%08lx:\n%T\n",
-             (unsigned long)ptr_val(dest),dest));
-
-    ma_gc_flags &= ~GC_CYCLE_START;
-
-    ASSERT(eq(orig, dest));
-    ASSERT(ma_src_top == 0);
-    ASSERT(ma_dst_top == 0);
-    ASSERT(ma_offset_top == 0);
-    return dest;
-}
-
-#undef NO_COPY
-#endif /* HYBRID */
-
 /*
  * Copy a term that is guaranteed to be contained in a single
  * heap block. The heap block is copied word by word, and any