Improve binary garbage collection

The garbage collector in r13b03 is too aggressive in some cases. This
commit raises the level of default initial allowed binary garbage
(virtual heap for binaries) before collecting from 233 words to
46368 words (181 kB on 32-bit).

A new option, min_bin_vheap_size, has been added to spawn_opt,
system_flag and process_flag can be used to change the default values.

The option can also be used with system_info and process_info to
inspect the values.

For symmetry the option min_heap_size has been added to the above
functions where it was previously missing.

Add testcases for min_bin_vheap_size and min_heap_size for
functions process_flag/2, process_info/2, system_info/2 and
spawn_opt/2.

8 files changed, 179 insertions, 48 deletions

diff --git a/erts/emulator/beam/atom.names b/erts/emulator/beam/atom.names
index 3ce26c4a7a..57c8b08223 100644
--- a/erts/emulator/beam/atom.names
+++ b/erts/emulator/beam/atom.names
@@ -303,6 +303,7 @@ atom messages
 atom meta
 atom meta_match_spec
 atom min_heap_size
+atom min_bin_vheap_size
 atom minor_version
 atom Minus='-'
 atom module
diff --git a/erts/emulator/beam/bif.c b/erts/emulator/beam/bif.c
index 74b231d56d..a6668d5665 100644
--- a/erts/emulator/beam/bif.c
+++ b/erts/emulator/beam/bif.c
@@ -807,11 +807,12 @@ BIF_RETTYPE spawn_opt_1(BIF_ALIST_1)
     /*
      * Store default values for options.
      */
-    so.flags = SPO_USE_ARGS;
-    so.min_heap_size = H_MIN_SIZE;
-    so.priority = PRIORITY_NORMAL;
-    so.max_gen_gcs = (Uint16) erts_smp_atomic_read(&erts_max_gen_gcs);
-    so.scheduler = 0;
+    so.flags          = SPO_USE_ARGS;
+    so.min_heap_size  = H_MIN_SIZE;
+    so.min_vheap_size = BIN_VH_MIN_SIZE;
+    so.priority       = PRIORITY_NORMAL;
+    so.max_gen_gcs    = (Uint16) erts_smp_atomic_read(&erts_max_gen_gcs);
+    so.scheduler      = 0;
 
     /*
      * Walk through the option list.
@@ -850,6 +851,15 @@ BIF_RETTYPE spawn_opt_1(BIF_ALIST_1)
 		} else {
 		    so.min_heap_size = erts_next_heap_size(min_heap_size, 0);
 		}
+	    } else if (arg == am_min_bin_vheap_size && is_small(val)) {
+		Sint min_vheap_size = signed_val(val);
+		if (min_vheap_size < 0) {
+		    goto error;
+		} else if (min_vheap_size < BIN_VH_MIN_SIZE) {
+		    so.min_vheap_size = BIN_VH_MIN_SIZE;
+		} else {
+		    so.min_vheap_size = erts_next_heap_size(min_vheap_size, 0);
+		}
 	    } else if (arg == am_fullsweep_after && is_small(val)) {
 		Sint max_gen_gcs = signed_val(val);
 		if (max_gen_gcs < 0) {
@@ -1485,6 +1495,23 @@ BIF_RETTYPE process_flag_2(BIF_ALIST_2)
        }
        BIF_RET(old_value);
    }
+   else if (BIF_ARG_1 == am_min_bin_vheap_size) {
+       Sint i;
+       if (!is_small(BIF_ARG_2)) {
+	   goto error;
+       }
+       i = signed_val(BIF_ARG_2);
+       if (i < 0) {
+	   goto error;
+       }
+       old_value = make_small(BIF_P->min_vheap_size);
+       if (i < BIN_VH_MIN_SIZE) {
+	   BIF_P->min_vheap_size = BIN_VH_MIN_SIZE;
+       } else {
+	   BIF_P->min_vheap_size = erts_next_heap_size(i, 0);
+       }
+       BIF_RET(old_value);
+   }
    else if (BIF_ARG_1 == am_sensitive) {
        Uint is_sensitive;
        if (BIF_ARG_2 == am_true) {
@@ -3736,10 +3763,35 @@ BIF_RETTYPE system_flag_2(BIF_ALIST_2)
 	BIF_RET(make_small(oval));
     } else if (BIF_ARG_1 == am_min_heap_size) {
 	int oval = H_MIN_SIZE;
+
 	if (!is_small(BIF_ARG_2) || (n = signed_val(BIF_ARG_2)) < 0) {
 	    goto error;
 	}
+
+	erts_smp_proc_unlock(BIF_P, ERTS_PROC_LOCK_MAIN);
+	erts_smp_block_system(0);
+
 	H_MIN_SIZE = erts_next_heap_size(n, 0);
+
+	erts_smp_release_system();
+	erts_smp_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
+
+	BIF_RET(make_small(oval));
+    } else if (BIF_ARG_1 == am_min_bin_vheap_size) {
+	int oval = BIN_VH_MIN_SIZE;
+
+	if (!is_small(BIF_ARG_2) || (n = signed_val(BIF_ARG_2)) < 0) {
+	    goto error;
+	}
+
+	erts_smp_proc_unlock(BIF_P, ERTS_PROC_LOCK_MAIN);
+	erts_smp_block_system(0);
+
+	BIN_VH_MIN_SIZE = erts_next_heap_size(n, 0);
+
+	erts_smp_release_system();
+	erts_smp_proc_lock(BIF_P, ERTS_PROC_LOCK_MAIN);
+
 	BIF_RET(make_small(oval));
     } else if (BIF_ARG_1 == am_display_items) {
 	int oval = display_items;
diff --git a/erts/emulator/beam/erl_bif_info.c b/erts/emulator/beam/erl_bif_info.c
index b2f81b6861..5ff1f794df 100644
--- a/erts/emulator/beam/erl_bif_info.c
+++ b/erts/emulator/beam/erl_bif_info.c
@@ -543,6 +543,8 @@ static Eterm pi_args[] = {
     am_last_calls,
     am_total_heap_size,
     am_suspending,
+    am_min_heap_size,
+    am_min_bin_vheap_size,
 #ifdef HYBRID
     am_message_binary
 #endif
@@ -589,8 +591,10 @@ pi_arg2ix(Eterm arg)
     case am_last_calls:				return 24;
     case am_total_heap_size:			return 25;
     case am_suspending:				return 26;
+    case am_min_heap_size:			return 27;
+    case am_min_bin_vheap_size:			return 28;
 #ifdef HYBRID
-    case am_message_binary:			return 27;
+    case am_message_binary:			return 29;
 #endif
     default:					return -1;
     }
@@ -1355,6 +1359,30 @@ process_info_aux(Process *BIF_P,
 	break;
     }
 
+    case am_fullsweep_after: {
+	Uint hsz = 3;
+	(void) erts_bld_uint(NULL, &hsz, MAX_GEN_GCS(rp));
+	hp = HAlloc(BIF_P, hsz);
+	res = erts_bld_uint(&hp, NULL, MAX_GEN_GCS(rp));
+	break;
+    }
+
+    case am_min_heap_size: {
+	Uint hsz = 3;
+	(void) erts_bld_uint(NULL, &hsz, MIN_HEAP_SIZE(rp));
+	hp = HAlloc(BIF_P, hsz);
+	res = erts_bld_uint(&hp, NULL, MIN_HEAP_SIZE(rp));
+	break;
+    }
+
+    case am_min_bin_vheap_size: {
+	Uint hsz = 3;
+	(void) erts_bld_uint(NULL, &hsz, MIN_VHEAP_SIZE(rp));
+	hp = HAlloc(BIF_P, hsz);
+	res = erts_bld_uint(&hp, NULL, MIN_VHEAP_SIZE(rp));
+	break;
+    }
+
     case am_total_heap_size: {
 	ErlMessage *mp;
 	Uint total_heap_size;
@@ -1433,15 +1461,17 @@ process_info_aux(Process *BIF_P,
         DECL_AM(minor_gcs);
         Eterm t;
 
-	hp = HAlloc(BIF_P, 3+2+3+2+3);
-	t = TUPLE2(hp, AM_minor_gcs, make_small(GEN_GCS(rp)));
-	hp += 3;
-	res = CONS(hp, t, NIL);
-	hp += 2;
-	t = TUPLE2(hp, am_fullsweep_after, make_small(MAX_GEN_GCS(rp)));
-	hp += 3;
-	res = CONS(hp, t, res);
-	hp += 2;
+	hp = HAlloc(BIF_P, 3+2 + 3+2 + 3+2 + 3+2 + 3); /* last "3" is for outside tuple */
+
+	t = TUPLE2(hp, AM_minor_gcs, make_small(GEN_GCS(rp))); hp += 3;
+	res = CONS(hp, t, NIL); hp += 2;
+	t = TUPLE2(hp, am_fullsweep_after, make_small(MAX_GEN_GCS(rp))); hp += 3;
+	res = CONS(hp, t, res); hp += 2;
+
+	t = TUPLE2(hp, am_min_heap_size, make_small(MIN_HEAP_SIZE(rp))); hp += 3;
+	res = CONS(hp, t, res); hp += 2;
+	t = TUPLE2(hp, am_min_bin_vheap_size, make_small(MIN_VHEAP_SIZE(rp))); hp += 3;
+	res = CONS(hp, t, res); hp += 2;
 	break;
     }
 
@@ -1897,16 +1927,32 @@ BIF_RETTYPE system_info_1(BIF_ALIST_1)
 	BIF_RET(res);
     } else if (BIF_ARG_1 == am_garbage_collection){
 	Uint val = (Uint) erts_smp_atomic_read(&erts_max_gen_gcs);
-	hp = HAlloc(BIF_P, 3+2);
-	res = TUPLE2(hp, am_fullsweep_after, make_small(val));
-	hp += 3;
-	res = CONS(hp, res, NIL);
+	Eterm tup;
+	hp = HAlloc(BIF_P, 3+2 + 3+2 + 3+2);
+
+	tup = TUPLE2(hp, am_fullsweep_after, make_small(val)); hp += 3;
+	res = CONS(hp, tup, NIL); hp += 2;
+
+	tup = TUPLE2(hp, am_min_heap_size, make_small(H_MIN_SIZE)); hp += 3;
+	res = CONS(hp, tup, res); hp += 2;
+
+	tup = TUPLE2(hp, am_min_bin_vheap_size, make_small(BIN_VH_MIN_SIZE)); hp += 3;
+	res = CONS(hp, tup, res); hp += 2;
+
 	BIF_RET(res);
     } else if (BIF_ARG_1 == am_fullsweep_after){
 	Uint val = (Uint) erts_smp_atomic_read(&erts_max_gen_gcs);
 	hp = HAlloc(BIF_P, 3);
 	res = TUPLE2(hp, am_fullsweep_after, make_small(val));
 	BIF_RET(res);
+    } else if (BIF_ARG_1 == am_min_heap_size) {
+	hp = HAlloc(BIF_P, 3);
+	res = TUPLE2(hp, am_min_heap_size,make_small(H_MIN_SIZE));
+	BIF_RET(res);
+    } else if (BIF_ARG_1 == am_min_bin_vheap_size) {
+	hp = HAlloc(BIF_P, 3);
+	res = TUPLE2(hp, am_min_bin_vheap_size,make_small(BIN_VH_MIN_SIZE));
+	BIF_RET(res);
     } else if (BIF_ARG_1 == am_process_count) {
 	BIF_RET(make_small(erts_process_count()));
     } else if (BIF_ARG_1 == am_process_limit) {
diff --git a/erts/emulator/beam/erl_gc.c b/erts/emulator/beam/erl_gc.c
index 363f956b58..e9bf37a173 100644
--- a/erts/emulator/beam/erl_gc.c
+++ b/erts/emulator/beam/erl_gc.c
@@ -2031,23 +2031,45 @@ shrink_new_heap(Process *p, Uint new_sz, Eterm *objv, int nobj)
 }
 
 static Uint
-next_vheap_size(Uint vheap, Uint vheap_sz) {
-    if (vheap < H_MIN_SIZE) {
-    	return H_MIN_SIZE;
-    }
+do_next_vheap_size(Uint vheap, Uint vheap_sz) {
+
+    /*                grow
+     *
+     * vheap_sz ======================
+     *
+     * vheap 75% +    grow
+     *          ----------------------
+     *
+     * vheap 25 - 75% same
+     *          ----------------------
+     *
+     * vheap ~ - 25% shrink
+     *
+     *          ----------------------
+     */
 
-    /* grow */
-    if (vheap > vheap_sz) {
-    	return erts_next_heap_size(2*vheap, 0);
+    if (vheap > (Uint) (vheap_sz*3/4)) {
+
+	while(vheap > (Uint) (vheap_sz*3/4)) {
+	    vheap_sz = vheap_sz*2;
+	}
+
+	return erts_next_heap_size(vheap_sz, 0);
     }
-    /* shrink */
-    if ( vheap < vheap_sz/2) {
-	return (Uint)vheap_sz*3/4;
+
+    if (vheap < (Uint) (vheap_sz/4)) {
+	return erts_next_heap_size((Uint) (vheap_sz / 2), 0);
     }
 
     return vheap_sz;
+
 }
 
+static Uint
+next_vheap_size(Process* p, Uint vheap, Uint vheap_sz) {
+    vheap_sz = do_next_vheap_size(vheap, vheap_sz);
+    return vheap_sz < p->min_vheap_size ? p->min_vheap_size : vheap_sz;
+}
 
 static void
 sweep_proc_externals(Process *p, int fullsweep)
@@ -2250,8 +2272,8 @@ sweep_proc_bins(Process *p, int fullsweep)
         FLAGS(p) |= F_NEED_FULLSWEEP;
     }
 
-    BIN_VHEAP_SZ(p) = next_vheap_size(bin_vheap, BIN_VHEAP_SZ(p));
-    BIN_OLD_VHEAP_SZ(p) = next_vheap_size(BIN_OLD_VHEAP(p), BIN_OLD_VHEAP_SZ(p));
+    BIN_VHEAP_SZ(p) = next_vheap_size(p, bin_vheap, BIN_VHEAP_SZ(p));
+    BIN_OLD_VHEAP_SZ(p) = next_vheap_size(p, BIN_OLD_VHEAP(p), BIN_OLD_VHEAP_SZ(p));
     MSO(p).overhead = bin_vheap;
 
     /*
diff --git a/erts/emulator/beam/erl_init.c b/erts/emulator/beam/erl_init.c
index 8afd349b85..5d2d119b14 100644
--- a/erts/emulator/beam/erl_init.c
+++ b/erts/emulator/beam/erl_init.c
@@ -84,9 +84,10 @@ int erts_use_sender_punish;
  * Configurable parameters.
  */
 
-Uint display_items;	    /* no of items to display in traces etc */
+Uint display_items;	    	/* no of items to display in traces etc */
 Uint display_loads;		/* print info about loaded modules */
 int H_MIN_SIZE;			/* The minimum heap grain */
+int BIN_VH_MIN_SIZE;		/* The minimum binary virtual*/
 
 Uint32 erts_debug_flags;	/* Debug flags. */
 #ifdef ERTS_OPCODE_COUNTER_SUPPORT
@@ -252,7 +253,8 @@ erl_init(void)
 			 no_schedulers,
 			 no_schedulers_online);
 
-    H_MIN_SIZE = erts_next_heap_size(H_MIN_SIZE, 0);
+    H_MIN_SIZE      = erts_next_heap_size(H_MIN_SIZE, 0);
+    BIN_VH_MIN_SIZE = erts_next_heap_size(BIN_VH_MIN_SIZE, 0);
 
     erts_init_trace();
     erts_init_binary();
@@ -604,6 +606,7 @@ early_init(int *argc, char **argv) /*
     erts_async_max_threads = 0;
     erts_async_thread_suggested_stack_size = ERTS_ASYNC_THREAD_MIN_STACK_SIZE;
     H_MIN_SIZE = H_DEFAULT_SIZE;
+    BIN_VH_MIN_SIZE = VH_DEFAULT_SIZE;
 
     erts_initialized = 0;
 
diff --git a/erts/emulator/beam/erl_process.c b/erts/emulator/beam/erl_process.c
index a4afe0574f..ed907f05de 100644
--- a/erts/emulator/beam/erl_process.c
+++ b/erts/emulator/beam/erl_process.c
@@ -6272,7 +6272,7 @@ Process *schedule(Process *p, int calls)
 	    erts_check_my_tracer_proc(p);
 #endif
 
-	if ((FLAGS(p) & F_FORCE_GC) || (MSO(p).overhead >= BIN_VHEAP_SZ(p))) {
+	if ((FLAGS(p) & F_FORCE_GC) || (MSO(p).overhead > BIN_VHEAP_SZ(p))) {
 	    reds -= erts_garbage_collect(p, 0, p->arg_reg, p->arity);
 	    if (reds < 0) {
 		reds = 1;
@@ -6683,13 +6683,15 @@ erl_create_process(Process* parent, /* Parent of process (default group leader).
      * noone except us has access to the process.
      */
     if (so->flags & SPO_USE_ARGS) {
-	p->min_heap_size = so->min_heap_size;
-	p->prio = so->priority;
-	p->max_gen_gcs = so->max_gen_gcs;
+	p->min_heap_size  = so->min_heap_size;
+	p->min_vheap_size = so->min_vheap_size;
+	p->prio           = so->priority;
+	p->max_gen_gcs    = so->max_gen_gcs;
     } else {
-	p->min_heap_size = H_MIN_SIZE;
-	p->prio = PRIORITY_NORMAL;
-	p->max_gen_gcs = (Uint16) erts_smp_atomic_read(&erts_max_gen_gcs);
+	p->min_heap_size  = H_MIN_SIZE;
+	p->min_vheap_size = BIN_VH_MIN_SIZE;
+	p->prio           = PRIORITY_NORMAL;
+	p->max_gen_gcs    = (Uint16) erts_smp_atomic_read(&erts_max_gen_gcs);
     }
     p->skipped = 0;
     ASSERT(p->min_heap_size == erts_next_heap_size(p->min_heap_size, 0));
@@ -6736,9 +6738,9 @@ erl_create_process(Process* parent, /* Parent of process (default group leader).
     p->heap_sz = sz;
     p->catches = 0;
 
-    p->bin_vheap_sz = H_MIN_SIZE;
-    p->bin_old_vheap_sz = H_MIN_SIZE;
-    p->bin_old_vheap = 0;
+    p->bin_vheap_sz     = p->min_vheap_size;
+    p->bin_old_vheap_sz = p->min_vheap_size;
+    p->bin_old_vheap    = 0;
 
     /* No need to initialize p->fcalls. */
 
@@ -6969,6 +6971,7 @@ void erts_init_empty_process(Process *p)
     p->gen_gcs = 0;
     p->max_gen_gcs = 0;
     p->min_heap_size = 0;
+    p->min_vheap_size = 0;
     p->status = P_RUNABLE;
     p->gcstatus = P_RUNABLE;
     p->rstatus = P_RUNABLE;
@@ -6985,8 +6988,8 @@ void erts_init_empty_process(Process *p)
     p->ftrace = NIL;
     p->fcalls = 0;
 
-    p->bin_vheap_sz=H_MIN_SIZE;
-    p->bin_old_vheap_sz=H_MIN_SIZE;
+    p->bin_vheap_sz = BIN_VH_MIN_SIZE;
+    p->bin_old_vheap_sz = BIN_VH_MIN_SIZE;
     p->bin_old_vheap = 0;
 #ifdef ERTS_SMP
     p->u.ptimer = NULL;
diff --git a/erts/emulator/beam/erl_process.h b/erts/emulator/beam/erl_process.h
index 1f841b2113..f58b6932b3 100644
--- a/erts/emulator/beam/erl_process.h
+++ b/erts/emulator/beam/erl_process.h
@@ -477,6 +477,7 @@ struct ErtsPendingSuspend_ {
 #  define MSO(p)            (p)->off_heap
 #  define MIN_HEAP_SIZE(p)  (p)->min_heap_size
 
+#  define MIN_VHEAP_SIZE(p)   (p)->min_vheap_size
 #  define BIN_VHEAP_SZ(p)     (p)->bin_vheap_sz
 #  define BIN_OLD_VHEAP_SZ(p) (p)->bin_old_vheap_sz
 #  define BIN_OLD_VHEAP(p)    (p)->bin_old_vheap
@@ -495,6 +496,7 @@ struct process {
     Eterm* hend;		/* Heap end */
     Uint heap_sz;		/* Size of heap in words */
     Uint min_heap_size;         /* Minimum size of heap (in words). */
+    Uint min_vheap_size;        /* Minimum size of virtual heap (in words). */
 
 #if !defined(NO_FPE_SIGNALS)
     volatile unsigned long fp_exception;
@@ -730,8 +732,8 @@ typedef struct {
      * The following items are only initialized if the SPO_USE_ARGS flag is set.
      */
     Uint min_heap_size;		/* Minimum heap size (must be a valued returned
-				 * from next_heap_size()).
-				 */
+				 * from next_heap_size()).  */
+    Uint min_vheap_size;	/* Minimum virtual heap size  */
     int priority;		/* Priority for process. */
     Uint16 max_gen_gcs;		/* Maximum number of gen GCs before fullsweep. */
     int scheduler;
diff --git a/erts/emulator/beam/erl_vm.h b/erts/emulator/beam/erl_vm.h
index d8d6246cfd..5b0d3c2bfa 100644
--- a/erts/emulator/beam/erl_vm.h
+++ b/erts/emulator/beam/erl_vm.h
@@ -57,7 +57,8 @@
 
 #define INPUT_REDUCTIONS (2 * CONTEXT_REDS)
 
-#define H_DEFAULT_SIZE  233     /* default (heap + stack) min size */
+#define H_DEFAULT_SIZE  233        /* default (heap + stack) min size */
+#define VH_DEFAULT_SIZE  32768     /* default virtual (bin) heap min size (words) */
 
 #ifdef HYBRID
 #  define SH_DEFAULT_SIZE  2629425 /* default message area min size */
@@ -178,6 +179,7 @@ extern int num_instructions;	/* Number of instruction in opc[]. */
 #define MAX_PORT_LINK 8		/* Maximum number of links to a port        */
 
 extern int H_MIN_SIZE;		/* minimum (heap + stack) */
+extern int BIN_VH_MIN_SIZE;	/* minimum virtual (bin) heap */
 
 #define ORIG_CREATION 0