Merge branch 'sverk/proc-dict-opt'

OTP-13167

* sverk/proc-dict-opt:
  erts: Add new test case pdict_SUITE:mixed
  erts: Add 'fill_heap' to erts_debug:state_internal_state
  erts: Rename proc dict size to arraySize
  erts: Refactor proc dict with 'usedSlots'
  erts: Add sizeMask for faster proc dict indexing
  erts: Remove ProcDict.used
  erts: Add proc dict macros ERTS_PD_START/SIZE
  erts: Optimize away function "array_put" in proc dict
  erts: Optimize hashing in process dictionary

8 files changed, 191 insertions, 98 deletions

diff --git a/erts/emulator/beam/beam_bif_load.c b/erts/emulator/beam/beam_bif_load.c
index 956454d9b3..6bb70cc5a7 100644
--- a/erts/emulator/beam/beam_bif_load.c
+++ b/erts/emulator/beam/beam_bif_load.c
@@ -866,8 +866,8 @@ check_process_code(Process* rp, Module* modp, int allow_gc, int *redsp)
 
 	/* Check dictionary */
 	if (rp->dictionary) {
-	    Eterm* start = rp->dictionary->data;
-	    Eterm* end = start + rp->dictionary->used;
+	    Eterm* start = ERTS_PD_START(rp->dictionary);
+	    Eterm* end = start + ERTS_PD_SIZE(rp->dictionary);
 
 	    if (any_heap_ref_ptrs(start, end, literals, lit_bsize))
 		goto try_literal_gc;
diff --git a/erts/emulator/beam/erl_bif_info.c b/erts/emulator/beam/erl_bif_info.c
index ab3ebd6bac..e69908bbef 100644
--- a/erts/emulator/beam/erl_bif_info.c
+++ b/erts/emulator/beam/erl_bif_info.c
@@ -4081,6 +4081,17 @@ BIF_RETTYPE erts_debug_set_internal_state_2(BIF_ALIST_2)
 		BIF_RET(am_ok);
 	    }
 	}
+        else if (ERTS_IS_ATOM_STR("fill_heap", BIF_ARG_1)) {
+            UWord left = HeapWordsLeft(BIF_P);
+            if (left > 1) {
+                Eterm* hp = HAlloc(BIF_P, left);
+                *hp = make_pos_bignum_header(left - 1);
+            }
+            if (BIF_ARG_2 == am_true) {
+                FLAGS(BIF_P) |= F_NEED_FULLSWEEP;
+            }
+            BIF_RET(am_ok);
+        }
     }
 
     BIF_ERROR(BIF_P, BADARG);
diff --git a/erts/emulator/beam/erl_debug.c b/erts/emulator/beam/erl_debug.c
index 49b08c8536..7b13cf2c83 100644
--- a/erts/emulator/beam/erl_debug.c
+++ b/erts/emulator/beam/erl_debug.c
@@ -418,7 +418,7 @@ void verify_process(Process *p)
     erts_check_heap(p);
 
     if (p->dictionary)
-        VERIFY_AREA("dictionary",p->dictionary->data, p->dictionary->used);
+        VERIFY_AREA("dictionary", ERTS_PD_START(p->dictionary), ERTS_PD_SIZE(p->dictionary));
     VERIFY_ETERM("seq trace token",p->seq_trace_token);
     VERIFY_ETERM("group leader",p->group_leader);
     VERIFY_ETERM("fvalue",p->fvalue);
@@ -544,8 +544,8 @@ static void print_process_memory(Process *p)
     }
 
     if (p->dictionary != NULL) {
-        int n = p->dictionary->used;
-        Eterm *ptr = p->dictionary->data;
+        int n = ERTS_PD_SIZE(p->dictionary);
+        Eterm *ptr = ERTS_PD_START(p->dictionary);
         erts_printf("  Dictionary: ");
         while (n--) erts_printf("0x%0*lx ",PTR_SIZE,(unsigned long)ptr++);
         erts_printf("\n");
diff --git a/erts/emulator/beam/erl_gc.c b/erts/emulator/beam/erl_gc.c
index f1962e5cac..0f86b9a25c 100644
--- a/erts/emulator/beam/erl_gc.c
+++ b/erts/emulator/beam/erl_gc.c
@@ -2203,8 +2203,8 @@ setup_rootset(Process *p, Eterm *objv, int nobj, Rootset *rootset)
     ++n;
 
     if (p->dictionary != NULL) {
-        roots[n].v = p->dictionary->data;
-        roots[n].sz = p->dictionary->used;
+        roots[n].v = ERTS_PD_START(p->dictionary);
+        roots[n].sz = ERTS_PD_SIZE(p->dictionary);
         ++n;
     }
     if (nobj > 0) {
@@ -2818,8 +2818,8 @@ offset_one_rootset(Process *p, Sint offs, char* area, Uint area_size,
 	       Eterm* objv, int nobj)
 {
     if (p->dictionary)  {
-	offset_heap(p->dictionary->data, 
-		    p->dictionary->used, 
+	offset_heap(ERTS_PD_START(p->dictionary),
+		    ERTS_PD_SIZE(p->dictionary),
 		    offs, area, area_size);
     }
 
diff --git a/erts/emulator/beam/erl_init.c b/erts/emulator/beam/erl_init.c
index e3390c2769..58ef09662c 100644
--- a/erts/emulator/beam/erl_init.c
+++ b/erts/emulator/beam/erl_init.c
@@ -192,7 +192,7 @@ Uint32 verbose;             /* See erl_debug.h for information about verbose */
 
 int erts_atom_table_size = ATOM_LIMIT;	/* Maximum number of atoms */
 
-int erts_pd_initial_size = 10;
+int erts_pd_initial_size = 8;  /* must be power of 2 */
 
 int erts_modified_timing_level;
 
@@ -1479,7 +1479,7 @@ erl_start(int argc, char **argv)
 		VERBOSE(DEBUG_SYSTEM, ("using minimum heap size %d\n", H_MIN_SIZE));
 	    } else if (has_prefix("pds", sub_param)) {
 		arg = get_arg(sub_param+3, argv[i+1], &i);
-		if ((erts_pd_initial_size = atoi(arg)) <= 0) {
+		if (!erts_pd_set_initial_size(atoi(arg))) {
 		    erts_fprintf(stderr, "bad initial process dictionary size %s\n", arg);
 		    erts_usage();
 		}
diff --git a/erts/emulator/beam/erl_process_dict.c b/erts/emulator/beam/erl_process_dict.c
index da9ebd92ab..84cd81aecf 100644
--- a/erts/emulator/beam/erl_process_dict.c
+++ b/erts/emulator/beam/erl_process_dict.c
@@ -51,7 +51,7 @@
 #define INITIAL_SIZE        (erts_pd_initial_size)
 
 /* Hash utility macros  */
-#define HASH_RANGE(PDict) ((PDict)->homeSize + (PDict)->splitPosition)
+#define HASH_RANGE(PDict) ((PDict)->usedSlots)
 
 #define MAKE_HASH(Term)                                \
     ((is_small(Term)) ? unsigned_val(Term) :           \
@@ -77,8 +77,12 @@
 #define TCDR(Term) CDR(list_val(Term))
 
 /* Array access macro */ 
-#define ARRAY_GET(PDict, Index) (((PDict)->size > (Index)) ? \
-				 (PDict)->data[Index] : NIL)
+#define ARRAY_GET(PDict, Index) (ASSERT((Index) < (PDict)->arraySize), \
+				 (PDict)->data[Index])
+#define ARRAY_PUT(PDict, Index, Val) (ASSERT((Index) < (PDict)->arraySize), \
+                                      (PDict)->data[Index] = (Val))
+
+#define IS_POW2(X) ((X) && !((X) & ((X)-1)))
 
 /*
  * Forward decalarations
@@ -95,7 +99,7 @@ static void shrink(Process *p, Eterm* ret);
 static void grow(Process *p);
 
 static void array_shrink(ProcDict **ppd, unsigned int need);
-static Eterm array_put(ProcDict **ppdict, unsigned int ndx, Eterm term);
+static void ensure_array_size(ProcDict**, unsigned int size);
 
 static unsigned int pd_hash_value_to_ix(ProcDict *pdict, Uint32 hx);
 static unsigned int next_array_size(unsigned int need);
@@ -138,6 +142,16 @@ static void pd_check(ProcDict *pd);
 ** External interface
 */
 
+int
+erts_pd_set_initial_size(int size)
+{
+    if (size <= 0)
+	return 0;
+
+    erts_pd_initial_size = 1 << erts_fit_in_bits_uint(size-1);
+    return 1;
+}
+
 /*
  * Called from break handler
  */
@@ -150,9 +164,9 @@ erts_dictionary_dump(int to, void *to_arg, ProcDict *pd)
     /*PD_CHECK(pd);*/
     if (pd == NULL)
 	return;
-    erts_print(to, to_arg, "(size = %d, used = %d, homeSize = %d, "
+    erts_print(to, to_arg, "(size = %d, usedSlots = %d, "
 	       "splitPosition = %d, numElements = %d)\n",
-	       pd->size, pd->used, pd->homeSize, 
+	       pd->arraySize, pd->usedSlots,
 	       pd->splitPosition, (unsigned int) pd->numElements);
     for (i = 0; i < HASH_RANGE(pd); ++i) {
 	erts_print(to, to_arg, "%d: %T\n", i, ARRAY_GET(pd, i));
@@ -207,7 +221,7 @@ erts_dicts_mem_size(Process *p)
 {
     Uint size = 0;
     if (p->dictionary)
-	size += PD_SZ2BYTES(p->dictionary->size);
+	size += PD_SZ2BYTES(p->dictionary->arraySize);
     return size;
 }
 
@@ -349,7 +363,7 @@ static void pd_hash_erase(Process *p, Eterm id, Eterm *ret)
     if (is_boxed(old)) {	/* Tuple */
 	ASSERT(is_tuple(old));
 	if (EQ(tuple_val(old)[1], id)) {
-	    array_put(&(p->dictionary), hval, NIL);
+	    ARRAY_PUT(p->dictionary, hval, NIL);
 	    --(p->dictionary->numElements);
 	    *ret = tuple_val(old)[2];
 	}
@@ -369,7 +383,7 @@ static void pd_hash_erase(Process *p, Eterm id, Eterm *ret)
 	old = ARRAY_GET(p->dictionary, hval);
 	ASSERT(is_list(old));
 	if (is_nil(TCDR(old))) {
-	    array_put(&p->dictionary, hval, TCAR(old));
+	    ARRAY_PUT(p->dictionary, hval, TCAR(old));
 	}
     } else if (is_not_nil(old)) {
 #ifdef DEBUG
@@ -399,6 +413,7 @@ Eterm erts_pd_hash_get_with_hx(Process *p, Uint32 hx, Eterm id)
     unsigned int hval;
     ProcDict *pd = p->dictionary;
 
+    ASSERT(hx == MAKE_HASH(id));
     if (pd == NULL)
 	return am_undefined;
     hval = pd_hash_value_to_ix(pd, hx);
@@ -568,8 +583,11 @@ static Eterm pd_hash_put(Process *p, Eterm id, Eterm value)
 
     if (p->dictionary == NULL) {
 	/* Create it */
-	array_put(&(p->dictionary), INITIAL_SIZE - 1, NIL);
-	p->dictionary->homeSize = INITIAL_SIZE;
+        ensure_array_size(&p->dictionary, INITIAL_SIZE);
+	p->dictionary->usedSlots = INITIAL_SIZE;
+        p->dictionary->sizeMask = INITIAL_SIZE*2 - 1;
+        p->dictionary->splitPosition = 0;
+        p->dictionary->numElements = 0;
     }	
     hval = pd_hash_value(p->dictionary, id);
     old = ARRAY_GET(p->dictionary, hval);
@@ -621,19 +639,19 @@ static Eterm pd_hash_put(Process *p, Eterm id, Eterm value)
      * Update the dictionary.
      */
     if (is_nil(old)) {
-	array_put(&(p->dictionary), hval, tpl);
+	ARRAY_PUT(p->dictionary, hval, tpl);
 	++(p->dictionary->numElements);
     } else if (is_boxed(old)) {
 	ASSERT(is_tuple(old));
 	if (EQ(tuple_val(old)[1],id)) {
-	    array_put(&(p->dictionary), hval, tpl);
+	    ARRAY_PUT(p->dictionary, hval, tpl);
 	    return tuple_val(old)[2];
 	} else {
 	    hp = HeapOnlyAlloc(p, 4);
 	    tmp = CONS(hp, old, NIL);
 	    hp += 2;
 	    ++(p->dictionary->numElements);
-	    array_put(&(p->dictionary), hval, CONS(hp, tpl, tmp));
+	    ARRAY_PUT(p->dictionary, hval, CONS(hp, tpl, tmp));
 	    hp += 2;
 	    ASSERT(hp <= hp_limit);
 	}
@@ -643,7 +661,7 @@ static Eterm pd_hash_put(Process *p, Eterm id, Eterm value)
 	     * New key. Simply prepend the tuple to the beginning of the list.
 	     */
 	    hp = HeapOnlyAlloc(p, 2);
-	    array_put(&(p->dictionary), hval, CONS(hp, tpl, old));
+	    ARRAY_PUT(p->dictionary, hval, CONS(hp, tpl, old));
 	    hp += 2;
 	    ASSERT(hp <= hp_limit);
 	    ++(p->dictionary->numElements);
@@ -678,7 +696,7 @@ static Eterm pd_hash_put(Process *p, Eterm id, Eterm value)
 	    nlist = CONS(hp, tpl, nlist);
 	    hp += 2;
 	    ASSERT(hp <= hp_limit);
-	    array_put(&(p->dictionary), hval, nlist);
+	    ARRAY_PUT(p->dictionary, hval, nlist);
 	    return tuple_val(TCAR(tmp))[2];
 	}
     } else {
@@ -703,6 +721,7 @@ static Eterm pd_hash_put(Process *p, Eterm id, Eterm value)
 
 static void shrink(Process *p, Eterm* ret) 
 {
+    ProcDict *pd = p->dictionary;
     unsigned int range = HASH_RANGE(p->dictionary);
     unsigned int steps = (range*3) / 10;
     Eterm hi, lo, tmp;
@@ -717,17 +736,18 @@ static void shrink(Process *p, Eterm* ret)
     }
 
     for (i = 0; i < steps; ++i) {
-	ProcDict *pd = p->dictionary;
 	if (pd->splitPosition == 0) {
-	    pd->homeSize /= 2;
-	    pd->splitPosition = pd->homeSize;
+            ASSERT(IS_POW2(pd->usedSlots));
+            pd->sizeMask = pd->usedSlots - 1;
+	    pd->splitPosition = pd->usedSlots / 2;
 	}
 	--(pd->splitPosition);
-	hi = ARRAY_GET(pd, (pd->splitPosition + pd->homeSize));
+        /* Must wait to decrement 'usedSlots' for GC rootset below */
+	hi = ARRAY_GET(pd, pd->usedSlots - 1);
 	lo = ARRAY_GET(pd, pd->splitPosition);
 	if (hi != NIL) {
 	    if (lo == NIL) {
-		array_put(&(p->dictionary), pd->splitPosition, hi);
+		ARRAY_PUT(pd, pd->splitPosition, hi);
 	    } else {
 		int needed = 4;
 		if (is_list(hi) && is_list(lo)) {
@@ -735,7 +755,7 @@ static void shrink(Process *p, Eterm* ret)
 		}
 		if (HeapWordsLeft(p) < needed) {
 		    erts_garbage_collect(p, needed, ret, 1);
-		    hi = pd->data[(pd->splitPosition + pd->homeSize)];
+		    hi = pd->data[pd->usedSlots - 1];
 		    lo = pd->data[pd->splitPosition];
 		}
 #ifdef DEBUG
@@ -746,13 +766,13 @@ static void shrink(Process *p, Eterm* ret)
 			hp = HeapOnlyAlloc(p, 4);
 			tmp = CONS(hp, hi, NIL);
 			hp += 2;
-			array_put(&(p->dictionary), pd->splitPosition, 
+			ARRAY_PUT(pd, pd->splitPosition,
 				  CONS(hp,lo,tmp));
 			hp += 2;
 			ASSERT(hp <= hp_limit);
 		    } else { /* hi is a list */
 			hp = HeapOnlyAlloc(p, 2);
-			array_put(&(p->dictionary), pd->splitPosition, 
+			ARRAY_PUT(pd, pd->splitPosition,
 				  CONS(hp, lo, hi));
 			hp += 2;
 			ASSERT(hp <= hp_limit);
@@ -760,7 +780,7 @@ static void shrink(Process *p, Eterm* ret)
 		} else { /* lo is a list */
 		    if (is_tuple(hi)) {
 			hp = HeapOnlyAlloc(p, 2);
-			array_put(&(p->dictionary), pd->splitPosition, 
+			ARRAY_PUT(pd, pd->splitPosition,
 				  CONS(hp, hi, lo));
 			hp += 2;
 			ASSERT(hp <= hp_limit);
@@ -772,14 +792,15 @@ static void shrink(Process *p, Eterm* ret)
 			    hp += 2;
 			}
 			ASSERT(hp <= hp_limit);
-			array_put(&(p->dictionary), pd->splitPosition, lo);
+			ARRAY_PUT(pd, pd->splitPosition, lo);
 		    }
 		}
 	    }
 	}
-	array_put(&(p->dictionary), (pd->splitPosition + pd->homeSize), NIL);
+        --pd->usedSlots;
+	ARRAY_PUT(pd, pd->usedSlots, NIL);
     }
-    if (HASH_RANGE(p->dictionary) <= (p->dictionary->size / 4)) {
+    if (HASH_RANGE(p->dictionary) <= (p->dictionary->arraySize / 4)) {
 	array_shrink(&(p->dictionary), (HASH_RANGE(p->dictionary) * 3) / 2);
     }
 }
@@ -787,14 +808,14 @@ static void shrink(Process *p, Eterm* ret)
 static void grow(Process *p)
 {
     unsigned int i,j;
-    unsigned int steps = p->dictionary->homeSize / 5;
+    unsigned int steps = (p->dictionary->usedSlots / 4) & 0xf;
     Eterm l1,l2;
     Eterm l;
     Eterm *hp;
     unsigned int pos;
     unsigned int homeSize;
     int needed = 0;
-    ProcDict *pd;
+    ProcDict *pd = p->dictionary;
 #ifdef DEBUG
     Eterm *hp_limit;
 #endif
@@ -803,18 +824,20 @@ static void grow(Process *p)
     if (steps == 0)
 	steps = 1;
     /* Dont grow over MAX_HASH */
-    if ((MAX_HASH - steps) <= HASH_RANGE(p->dictionary)) {
+    if ((MAX_HASH - steps) <= HASH_RANGE(pd)) {
 	return;
     }
 
+    ensure_array_size(&p->dictionary, HASH_RANGE(pd) + steps);
+    pd = p->dictionary;
+
     /*
      * Calculate total number of heap words needed, and garbage collect
      * if necessary.
      */
 
-    pd = p->dictionary;
     pos = pd->splitPosition;
-    homeSize = pd->homeSize;
+    homeSize = pd->usedSlots - pd->splitPosition;
     for (i = 0; i < steps; ++i) {
 	if (pos == homeSize) {
 	    homeSize *= 2;
@@ -839,21 +862,22 @@ static void grow(Process *p)
     /*
      * Now grow.
      */
-
+    homeSize = pd->usedSlots - pd->splitPosition;
     for (i = 0; i < steps; ++i) {
-	ProcDict *pd = p->dictionary;
-	if (pd->splitPosition == pd->homeSize) {
-	    pd->homeSize *= 2;
-	    pd->splitPosition = 0;
+	if (pd->splitPosition == homeSize) {
+	    homeSize *= 2;
+            pd->sizeMask = homeSize*2 - 1;
+            pd->splitPosition = 0;
 	}
 	pos = pd->splitPosition;
 	++pd->splitPosition; /* For the hashes */
+        ++pd->usedSlots;
+        ASSERT(pos + homeSize == pd->usedSlots - 1);
 	l = ARRAY_GET(pd, pos);
 	if (is_tuple(l)) {
 	    if (pd_hash_value(pd, tuple_val(l)[1]) != pos) {
-		array_put(&(p->dictionary), pos + 
-			  p->dictionary->homeSize, l);
-		array_put(&(p->dictionary), pos, NIL);
+		ARRAY_PUT(pd, pos + homeSize, l);
+		ARRAY_PUT(pd, pos, NIL);
 	    }
 	} else {
 	    l2 = NIL;
@@ -875,10 +899,8 @@ static void grow(Process *p)
 	    if (l2 != NIL && TCDR(l2) == NIL)
 		l2 = TCAR(l2);
 	    ASSERT(hp <= hp_limit);
-	    /* After array_put pd is no longer valid */
-	    array_put(&(p->dictionary), pos, l1);
-	    array_put(&(p->dictionary), pos + 
-		      p->dictionary->homeSize, l2);
+	    ARRAY_PUT(pd, pos, l1);
+	    ARRAY_PUT(pd, pos + homeSize, l2);
 	}
     }
 
@@ -895,56 +917,44 @@ static void array_shrink(ProcDict **ppd, unsigned int need)
 {
     unsigned int siz = next_array_size(need);
 
-    HDEBUGF(("array_shrink: size = %d, used = %d, need = %d",
-	     (*ppd)->size, (*ppd)->used, need));
+    HDEBUGF(("array_shrink: size = %d, need = %d",
+	     (*ppd)->arraySize, need));
 
-    if (siz > (*ppd)->size)
+    if (siz >= (*ppd)->arraySize)
 	return; /* Only shrink */
 
     *ppd = PD_REALLOC(((void *) *ppd),
-		      PD_SZ2BYTES((*ppd)->size),
+		      PD_SZ2BYTES((*ppd)->arraySize),
 		      PD_SZ2BYTES(siz));
 
-    (*ppd)->size = siz;
-    if ((*ppd)->size < (*ppd)->used)
-	(*ppd)->used = (*ppd)->size;
+    (*ppd)->arraySize = siz;
 }
     
 			
-static Eterm array_put(ProcDict **ppdict, unsigned int ndx, Eterm term)
+static void ensure_array_size(ProcDict **ppdict, unsigned int size)
 {
+    ProcDict *pd = *ppdict;
     unsigned int i;
-    Eterm ret;
-    if (*ppdict == NULL) {
-	Uint siz = next_array_size(ndx+1);
-	ProcDict *p;
 
-        p = PD_ALLOC(PD_SZ2BYTES(siz));
+    if (pd == NULL) {
+	Uint siz = next_array_size(size);
+
+        pd = PD_ALLOC(PD_SZ2BYTES(siz));
 	for (i = 0; i < siz; ++i) 
-	    p->data[i] = NIL;
-	p->size = siz;
-	p->homeSize = p->splitPosition = p->numElements = p->used = 0;
-	*ppdict = p;
-    } else if (ndx >= (*ppdict)->size) {
-	Uint osize = (*ppdict)->size;
-	Uint nsize = next_array_size(ndx+1);
-	*ppdict = PD_REALLOC(((void *) *ppdict),
+	    pd->data[i] = NIL;
+	pd->arraySize = siz;
+        *ppdict = pd;
+    } else if (size > pd->arraySize) {
+	Uint osize = pd->arraySize;
+	Uint nsize = next_array_size(size);
+	pd = PD_REALLOC(((void *) pd),
 			     PD_SZ2BYTES(osize),
 			     PD_SZ2BYTES(nsize));
 	for (i = osize; i < nsize; ++i)
-	    (*ppdict)->data[i] = NIL;
-	(*ppdict)->size = nsize;
+	    pd->data[i] = NIL;
+	pd->arraySize = nsize;
+        *ppdict = pd;
     }
-    ret = (*ppdict)->data[ndx];
-    (*ppdict)->data[ndx] = term;
-    if ((ndx + 1) > (*ppdict)->used)
-	(*ppdict)->used = ndx + 1;
-#ifdef HARDDEBUG
-    HDEBUGF(("array_put: (*ppdict)->size = %d, (*ppdict)->used = %d, ndx = %d",
-	     (*ppdict)->size, (*ppdict)->used, ndx));
-    erts_fprintf(stderr, "%T", term);
-#endif /* HARDDEBUG */
-    return ret;
 }
 
 /*
@@ -954,9 +964,14 @@ static Eterm array_put(ProcDict **ppdict, unsigned int ndx, Eterm term)
 static unsigned int pd_hash_value_to_ix(ProcDict *pdict, Uint32 hx) 
 { 
     Uint high;
-    high = hx % (pdict->homeSize*2);
+
+    ASSERT(IS_POW2(pdict->sizeMask+1));
+    ASSERT(HASH_RANGE(pdict) >= (pdict->sizeMask >> 1));
+    ASSERT(HASH_RANGE(pdict) <= (pdict->sizeMask + 1));
+
+    high = hx & pdict->sizeMask;
     if (high >= HASH_RANGE(pdict))
-	return hx % pdict->homeSize;
+	return hx & (pdict->sizeMask >> 1);
     return high;
 }
 
@@ -1020,24 +1035,28 @@ static unsigned int next_array_size(unsigned int need)
 static void pd_check(ProcDict *pd) 
 {
     unsigned int i;
+    unsigned int used;
     Uint num;
     if (pd == NULL)
 	return;
-    ASSERT(pd->size >= pd->used);
+    used = HASH_RANGE(pd);
+    ASSERT(pd->arraySize >= used);
     ASSERT(HASH_RANGE(pd) <= MAX_HASH);
-    for (i = 0, num = 0; i < pd->used; ++i) {
+    for (i = 0, num = 0; i < used; ++i) {
 	Eterm t = pd->data[i];
 	if (is_nil(t)) {
 	    continue;
 	} else if (is_tuple(t)) {
 	    ++num;
 	    ASSERT(arityval(*tuple_val(t)) == 2);
+            ASSERT(pd_hash_value(pd, tuple_val(t)[1]) == i);
 	    continue;
 	} else if (is_list(t)) {
 	    while (t != NIL) {
 		++num;
 		ASSERT(is_tuple(TCAR(t)));
 		ASSERT(arityval(*(tuple_val(TCAR(t)))) == 2);
+                ASSERT(pd_hash_value(pd, tuple_val(TCAR(t))[1]) == i);
 		t = TCDR(t);
 	    }
 	    continue;
@@ -1048,7 +1067,7 @@ static void pd_check(ProcDict *pd)
 	}
     }
     ASSERT(num == pd->numElements);
-    ASSERT(pd->splitPosition <= pd->homeSize);
+    ASSERT(pd->usedSlots >= pd->splitPosition*2);
 }
 
 #endif /* DEBUG */
diff --git a/erts/emulator/beam/erl_process_dict.h b/erts/emulator/beam/erl_process_dict.h
index 9aa21b7c38..dac214c8a1 100644
--- a/erts/emulator/beam/erl_process_dict.h
+++ b/erts/emulator/beam/erl_process_dict.h
@@ -23,14 +23,18 @@
 #include "sys.h"
 
 typedef struct proc_dict {
-    unsigned int size;
-    unsigned int used;
-    unsigned int homeSize;
+    unsigned int sizeMask;
+    unsigned int usedSlots;
+    unsigned int arraySize;
     unsigned int splitPosition;
     Uint numElements;
     Eterm data[1]; /* The beginning of an array of erlang terms */
 } ProcDict;
 
+#define ERTS_PD_START(PD) ((PD)->data)
+#define ERTS_PD_SIZE(PD)  ((PD)->usedSlots)
+
+int erts_pd_set_initial_size(int size);
 Uint erts_dicts_mem_size(struct process *p);
 void erts_erase_dicts(struct process *p);
 void erts_dictionary_dump(int to, void *to_arg, ProcDict *pd);
diff --git a/lib/kernel/test/pdict_SUITE.erl b/lib/kernel/test/pdict_SUITE.erl
index 6de4ff9f77..b096296fa1 100644
--- a/lib/kernel/test/pdict_SUITE.erl
+++ b/lib/kernel/test/pdict_SUITE.erl
@@ -32,6 +32,7 @@
 
 -export([all/0, suite/0,groups/0,init_per_suite/1, end_per_suite/1, 
 	 init_per_group/2,end_per_group/2,
+	 mixed/1,
 	 simple/1, complicated/1, heavy/1, simple_all_keys/1, info/1]).
 -export([init_per_testcase/2, end_per_testcase/2]).
 -export([other_process/2]).
@@ -47,7 +48,8 @@ end_per_testcase(_Case, Config) ->
 suite() -> [{ct_hooks,[ts_install_cth]}].
 
 all() -> 
-    [simple, complicated, heavy, simple_all_keys, info].
+    [simple, complicated, heavy, simple_all_keys, info,
+     mixed].
 
 groups() -> 
     [].
@@ -369,3 +371,60 @@ match_keys(All) ->
     Ks = lists:sort([K||{K,_}<-All]),
     Ks = lists:sort(erlang:get_keys()),
     ok.
+
+
+%% Do random mixed put/erase to test grow/shrink
+%% Written for a temporary bug in gc during shrink
+mixed(_Config) ->
+    Rand0 = rand:seed_s(exsplus),
+    io:format("Random seed = ~p\n\n", [rand:export_seed_s(Rand0)]),
+
+    erts_debug:set_internal_state(available_internal_state, true),
+    try
+	C = do_mixed([10,0,100,50,1000,500,600,100,150,1,11,2,30,0],
+		     0,
+		     array:new(),
+		     1,
+		     Rand0),
+	io:format("\nDid total of ~p operations\n", [C])
+    after
+	erts_debug:set_internal_state(available_internal_state, false)
+    end.
+
+do_mixed([], _, _, C, _) ->
+    C;
+do_mixed([GoalN | Tail], GoalN, Array, C, Rand0) ->
+    io:format("Reached goal of ~p keys in dict after ~p mixed ops\n",[GoalN, C]),
+    GoalN = array:size(Array),
+    do_mixed(Tail, GoalN, Array, C, Rand0);
+do_mixed([GoalN | _]=Goals, CurrN, Array0, C, Rand0) ->
+    CurrN = array:size(Array0),
+    GrowPercent = case GoalN > CurrN of
+		      true when CurrN == 0 -> 100;
+		      true -> 75;
+		      false -> 25
+		  end,
+    {R, Rand1} = rand:uniform_s(100, Rand0),
+    case R of
+	_ when R =< GrowPercent ->   %%%%%%%%%%%%% GROW
+	    {Key, Rand2} = rand:uniform_s(10000, Rand1),
+	    case put(Key, {Key,C}) of
+		undefined ->
+		    Array1 = array:set(CurrN, Key, Array0),
+		    do_mixed(Goals, CurrN+1, Array1, C+1, Rand2);
+		_ ->
+		    do_mixed(Goals, CurrN, Array0, C+1, Rand2)
+	    end;
+
+	_ ->                          %%%%%%%%%% SHRINK
+	    {Kix, Rand2} = rand:uniform_s(CurrN, Rand1),
+	    Key = array:get(Kix-1, Array0),
+
+	    %% provoke GC during shrink
+	    erts_debug:set_internal_state(fill_heap, true),
+
+	    {Key, _} = erase(Key),
+	    Array1 = array:set(Kix-1, array:get(CurrN-1, Array0), Array0),
+	    Array2 = array:resize(CurrN-1, Array1),
+	    do_mixed(Goals, CurrN-1, Array2, C+1, Rand2)
+    end.