Merge branch 'maint'

* maint:
  erts: Document the +M<S>acul command line argument
  erts: Carrier pool information in allocator information
  erts: Use carrier pool for migration of carriers
  erts: Implement test case for carrier pool
  erts: Implement carrier pool
  erts: Fix type errors in info functions
  erts: Use Uint64 for call counts
  erts: Fix failing testcase alloc_SUITE:rbtree
  erts: Rename allocator aoffcbf to aoffcaobf
  erts: Remove unnecessary flag arguments in allocators
  erts: Remove SBMBC allocator
  erts: Add test for add_mbc and remove_mbc callbacks
  erts: Fix deallocation in removed carrier
  erts: Change naive list to rb-tree of carriers in AOFF allocator
  erts: Prepare aoff allocator for carrier migration
  erts: Make carrier header sizes customizable
  erts: Add "bestfit within carrier" for aoff allocator (aoffcbf)

Conflicts:
	erts/preloaded/ebin/erlang.beam

9 files changed, 341 insertions, 29 deletions

diff --git a/erts/emulator/test/alloc_SUITE.erl b/erts/emulator/test/alloc_SUITE.erl
index 22b5d93983..33abd45982 100644
--- a/erts/emulator/test/alloc_SUITE.erl
+++ b/erts/emulator/test/alloc_SUITE.erl
@@ -28,7 +28,8 @@
 	 bucket_index/1,
 	 bucket_mask/1,
 	 rbtree/1,
-	 mseg_clear_cache/1]).
+	 mseg_clear_cache/1,
+	 cpool/1]).
 
 -export([init_per_testcase/2, end_per_testcase/2]).
 
@@ -40,7 +41,7 @@ suite() -> [{ct_hooks,[ts_install_cth]}].
 
 all() -> 
     [basic, coalesce, threads, realloc_copy, bucket_index,
-     bucket_mask, rbtree, mseg_clear_cache].
+     bucket_mask, rbtree, mseg_clear_cache, cpool].
 
 groups() -> 
     [].
@@ -105,6 +106,10 @@ mseg_clear_cache(suite) -> [];
 mseg_clear_cache(doc) ->   [];
 mseg_clear_cache(Cfg) -> ?line drv_case(Cfg).
 
+cpool(suite) -> [];
+cpool(doc) ->   [];
+cpool(Cfg) -> ?line drv_case(Cfg).
+
 %%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%
 %%                                                                        %%
 %% Internal functions                                                     %%
diff --git a/erts/emulator/test/alloc_SUITE_data/Makefile.src b/erts/emulator/test/alloc_SUITE_data/Makefile.src
index 035415d73e..1d4286e671 100644
--- a/erts/emulator/test/alloc_SUITE_data/Makefile.src
+++ b/erts/emulator/test/alloc_SUITE_data/Makefile.src
@@ -23,7 +23,8 @@ TEST_DRVS =	basic@dll@		\
 		bucket_index@dll@	\
 		bucket_mask@dll@	\
 		rbtree@dll@		\
-		mseg_clear_cache@dll@
+		mseg_clear_cache@dll@	\
+		cpool@dll@
 
 CC = @CC@
 LD = @LD@
diff --git a/erts/emulator/test/alloc_SUITE_data/allocator_test.h b/erts/emulator/test/alloc_SUITE_data/allocator_test.h
index c0396ddb61..c37b074f93 100644
--- a/erts/emulator/test/alloc_SUITE_data/allocator_test.h
+++ b/erts/emulator/test/alloc_SUITE_data/allocator_test.h
@@ -75,6 +75,15 @@ typedef void* erts_cond;
 #define PREV_BLK(B)		((Block_t *)	ALC_TEST1(0x019, (B)))
 #define IS_MBC_FIRST_BLK(A,B)	((Ulong)	ALC_TEST2(0x01a, (A), (B)))
 #define UNIT_SZ			((Ulong)	ALC_TEST0(0x01b))
+#define BLK_TO_MBC(B)		((Carrier_t *)	ALC_TEST1(0x01c, (B)))
+#define ADD_MBC(A, C)        	((void)	ALC_TEST2(0x01d, (A), (C)))
+#define REMOVE_MBC(A, C)       	((void)	ALC_TEST2(0x01e, (A), (C)))
+#define ZERO_CRR_SIZE		((Ulong)	ALC_TEST0(0x01f))
+#define ZERO_CRR_INIT(A,B)	((Carrier_t *)	ALC_TEST2(0x020, (A), (B)))
+#define CPOOL_INSERT(A,B)	((Carrier_t *)	ALC_TEST2(0x021, (A), (B)))
+#define CPOOL_DELETE(A,B)	((Carrier_t *)	ALC_TEST2(0x022, (A), (B)))
+#define CPOOL_IS_EMPTY(A)	((int)		ALC_TEST1(0x023, (A)))
+#define CPOOL_IS_IN_POOL(A,B)	((int)		ALC_TEST2(0x024, (A), (B)))
 
 /* From erl_goodfit_alloc.c */
 #define BKT_IX(A, S)		((Ulong)	ALC_TEST2(0x100, (A), (S)))
@@ -84,15 +93,16 @@ typedef void* erts_cond;
 
 /* From erl_bestfit_alloc.c and erl_ao_firstfit_alloc.c */
 #define IS_AOBF(A)		((Ulong)	ALC_TEST1(RBT_OP(0), (A)))
-#define RBT_ROOT(A)		((RBT_t *)	ALC_TEST1(RBT_OP(1), (A)))
+#define RBT_ROOT(A,SZ)		((RBT_t *)	ALC_TEST2(RBT_OP(1), (A), (SZ)))
 #define RBT_PARENT(T)		((RBT_t *)	ALC_TEST1(RBT_OP(2), (T)))
 #define RBT_LEFT(T)		((RBT_t *)	ALC_TEST1(RBT_OP(3), (T)))
 #define RBT_RIGHT(T)		((RBT_t *)	ALC_TEST1(RBT_OP(4), (T)))
 #define RBT_NEXT(T)		((RBTL_t *)	ALC_TEST1(RBT_OP(5), (T)))
 #define RBT_IS_BLACK(T)		((Ulong)	ALC_TEST1(RBT_OP(6), (T)))
 #define RBT_IS_TREE(T)		((Ulong)	ALC_TEST1(RBT_OP(7), (T)))
-#define IS_AOFF(A)		((Ulong)	ALC_TEST1(RBT_OP(8), (A)))
+#define IS_BF_ALGO(A)		((Ulong)	ALC_TEST1(RBT_OP(8), (A)))
 #define RBT_MAX_SZ(T)		((Ulong)	ALC_TEST1(RBT_OP(9), (T)))
+#define IS_CBF(A)		((Ulong)	ALC_TEST1(RBT_OP(0xa), (A)))
 
 /* From erl_mseg.c */
 #define HAVE_MSEG()		((int)		ALC_TEST0(0x400))
@@ -129,5 +139,6 @@ typedef void* erts_cond;
 #define THR_CREATE(F, A)	((erts_thread)	ALC_TEST2(0xf10, (F), (A)))
 #define THR_JOIN(T)		((void)		ALC_TEST1(0xf11, (T)))
 #define THR_EXIT(R)		((void)		ALC_TEST1(0xf12, (R)))
+#define IS_SMP_ENABLED		((int)		ALC_TEST0(0xf13))
 
 #endif
diff --git a/erts/emulator/test/alloc_SUITE_data/coalesce.c b/erts/emulator/test/alloc_SUITE_data/coalesce.c
index 981fa6d43e..36710bf7b5 100644
--- a/erts/emulator/test/alloc_SUITE_data/coalesce.c
+++ b/erts/emulator/test/alloc_SUITE_data/coalesce.c
@@ -267,7 +267,7 @@ void
 testcase_run(TestCaseState_t *tcs)
 {
     char *argv_org[] = {"-tsmbcs511","-tmmbcs511", "-tsbct512", "-trmbcmt100", "-tas", NULL, NULL};
-    char *alg[] = {"af", "gf", "bf", "aobf", "aoff", NULL};
+    char *alg[] = {"af", "gf", "bf", "aobf", "aoff", "aoffcaobf", NULL};
     int i;
 
     for (i = 0; alg[i]; i++) {
diff --git a/erts/emulator/test/alloc_SUITE_data/cpool.c b/erts/emulator/test/alloc_SUITE_data/cpool.c
new file mode 100644
index 0000000000..276ed7be04
--- /dev/null
+++ b/erts/emulator/test/alloc_SUITE_data/cpool.c
@@ -0,0 +1,157 @@
+/*
+ * %CopyrightBegin%
+ *
+ * Copyright Ericsson AB 2013. All Rights Reserved.
+ *
+ * The contents of this file are subject to the Erlang Public License,
+ * Version 1.1, (the "License"); you may not use this file except in
+ * compliance with the License. You should have received a copy of the
+ * Erlang Public License along with this software. If not, it can be
+ * retrieved online at http://www.erlang.org/.
+ *
+ * Software distributed under the License is distributed on an "AS IS"
+ * basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
+ * the License for the specific language governing rights and limitations
+ * under the License.
+ *
+ * %CopyrightEnd%
+ */
+
+
+#ifndef __WIN32__
+#include <sys/types.h>
+#include <unistd.h>
+#include <errno.h>
+#endif
+#include <stdio.h>
+#include <stdarg.h>
+#include <string.h>
+#include "testcase_driver.h"
+#include "allocator_test.h"
+
+#define FATAL_ASSERT(A)						\
+    ((void) ((A)						\
+	     ? 1						\
+	     : (fatal_assert_failed(#A,				\
+				    (char *) __FILE__,		\
+				    __LINE__),			\
+		0)))
+
+static void
+fatal_assert_failed(char* expr, char* file, int line)
+{
+    fflush(stdout);
+    fprintf(stderr, "%s:%d: Assertion failed: %s\n",
+	    file, line, expr);
+    fflush(stderr);
+    abort();
+}
+
+#define TEST_NO_THREADS 10
+#define TEST_NO_CARRIERS_PER_THREAD 100000
+#define TEST_CARRIERS_OFFSET 5
+
+static Allctr_t *alloc = NULL;
+
+static void stop_allocator(void)
+{
+    if (alloc) {
+	STOP_ALC(alloc);
+	alloc = NULL;
+    }
+}
+
+
+void *thread_func(void *arg);
+
+char *
+testcase_name(void)
+{
+    return "cpool";
+}
+
+void
+testcase_cleanup(TestCaseState_t *tcs)
+{
+    stop_allocator();
+}
+
+void *
+thread_func(void *arg)
+{
+    Carrier_t *crr = (Carrier_t *) arg;
+    int i;
+
+    for (i = 0; i < (TEST_NO_CARRIERS_PER_THREAD+TEST_CARRIERS_OFFSET); i++) {
+	int d;
+	if (i < TEST_NO_CARRIERS_PER_THREAD) {
+	    CPOOL_INSERT(alloc, crr[i]);
+	    if ((i & 0x7) == 0)
+		FATAL_ASSERT(CPOOL_IS_IN_POOL(alloc, crr[i]));
+	}
+	d = i-TEST_CARRIERS_OFFSET;
+	if (d >= 0) {
+	    CPOOL_DELETE(alloc, crr[d]);
+	    if ((d & 0x7) == 0)
+		FATAL_ASSERT(!CPOOL_IS_IN_POOL(alloc, crr[d]));
+	}
+    }
+    for (i = 0; i < TEST_NO_CARRIERS_PER_THREAD; i++)
+	FATAL_ASSERT(!CPOOL_IS_IN_POOL(alloc, crr[i]));
+    return NULL;
+}
+
+static struct {
+    erts_thread tid;
+    Carrier_t *crr[TEST_NO_CARRIERS_PER_THREAD];
+} threads[TEST_NO_THREADS] = {{0}};
+
+void
+testcase_run(TestCaseState_t *tcs)
+{
+    int no_threads, t, c;
+    char *block, *p;
+    Ulong zcrr_sz;
+
+    if (!IS_SMP_ENABLED)
+	testcase_skipped(tcs, "No SMP support");
+
+    alloc = START_ALC("Zero carrier allocator", 1, NULL);
+
+    zcrr_sz = ZERO_CRR_SIZE;
+
+    block = p = ALLOC(alloc, zcrr_sz*TEST_NO_THREADS*TEST_NO_CARRIERS_PER_THREAD);
+
+    ASSERT(tcs, block != NULL);    
+
+    for (t = 0; t < TEST_NO_THREADS; t++) {
+	for (c = 0; c < TEST_NO_CARRIERS_PER_THREAD; c++) {
+	    Carrier_t *crr = (Carrier_t *) p;
+	    p += zcrr_sz;
+	    ZERO_CRR_INIT(alloc, crr);
+	    threads[t].crr[c] = crr;
+	}
+    }
+
+    no_threads = 0;
+    for (t = 0; t < TEST_NO_THREADS; t++) {
+    	threads[t].tid = THR_CREATE(thread_func, (void *) threads[t].crr);
+	if (threads[t].tid) {
+	    testcase_printf(tcs, "Successfully created thread %d\n", t);
+	    no_threads++;
+	}
+	else {
+	    testcase_printf(tcs, "Failed to create thread %d\n", t);
+	    break;
+	}
+    }
+
+    for (t = 0; t < no_threads; t++)
+	THR_JOIN(threads[t].tid);
+
+    FATAL_ASSERT(CPOOL_IS_EMPTY(alloc));
+
+    FREE(alloc, block);
+
+    ASSERT(tcs, no_threads == TEST_NO_THREADS);
+}
diff --git a/erts/emulator/test/alloc_SUITE_data/rbtree.c b/erts/emulator/test/alloc_SUITE_data/rbtree.c
index 4e7f821baf..702f075304 100644
--- a/erts/emulator/test/alloc_SUITE_data/rbtree.c
+++ b/erts/emulator/test/alloc_SUITE_data/rbtree.c
@@ -85,7 +85,7 @@ print_tree(TestCaseState_t *tcs, RBT_t *root)
 static RBT_t *
 check_tree(TestCaseState_t *tcs, Allctr_t *alc, Ulong size)
 {
-    enum { BF, AOBF, AOFF }type;
+    enum { BF, AOBF, AOFF, AOFFCAOBF }type;
     int i, max_i;
     char stk[128];
     RBT_t *root, *x, *y, *res;
@@ -94,11 +94,16 @@ check_tree(TestCaseState_t *tcs, Allctr_t *alc, Ulong size)
 
     res = NULL;
 
-    if      (IS_AOBF(alc)) type = AOBF;
-    else if (IS_AOFF(alc)) type = AOFF;
-    else type = BF;
+    if (IS_BF_ALGO(alc)) {
+	if (IS_AOBF(alc)) type = AOBF;
+	else type = BF;
+    }
+    else { /* AOFF_ALGO */
+	if (IS_CBF(alc)) type = AOFFCAOBF;
+	else type = AOFF;
+    }
 
-    root = RBT_ROOT(alc);
+    root = RBT_ROOT(alc, size);
 
 #ifdef PRINT_TREE
     print_tree(tcs, root);
@@ -188,6 +193,15 @@ check_tree(TestCaseState_t *tcs, Allctr_t *alc, Ulong size)
 		ASSERT(tcs, y < x);
 		ASSERT(tcs, RBT_MAX_SZ(y) <= RBT_MAX_SZ(x));
 		break;
+	    case AOFFCAOBF:
+		{
+		    void* x_crr = BLK_TO_MBC(x);
+		    void* y_crr = BLK_TO_MBC(y);
+		    ASSERT(tcs, (y < x && (x_crr != y_crr || x_sz == y_sz))
+			   || (y_sz < x_sz && x_crr == y_crr));
+		    ASSERT(tcs, RBT_MAX_SZ(y) <= RBT_MAX_SZ(x));
+		    break;
+		}
 	    }
 	}
 
@@ -207,6 +221,15 @@ check_tree(TestCaseState_t *tcs, Allctr_t *alc, Ulong size)
 		ASSERT(tcs, y > x);
 		ASSERT(tcs, RBT_MAX_SZ(y) <= RBT_MAX_SZ(x));
 		break;
+	    case AOFFCAOBF:
+		{
+		    void* x_crr = BLK_TO_MBC(x);
+		    void* y_crr = BLK_TO_MBC(y);
+		    ASSERT(tcs, (y > x && (x_crr != y_crr || x_sz == y_sz))
+			   || (y_sz > x_sz && x_crr == y_crr));
+		    ASSERT(tcs, RBT_MAX_SZ(y) <= RBT_MAX_SZ(x));
+		    break;
+		}
 	    }
 	}
 
@@ -239,7 +262,18 @@ check_tree(TestCaseState_t *tcs, Allctr_t *alc, Ulong size)
 			res = x;
 		    }
 		    break;
+		case AOFFCAOBF:
+		    if (BLK_TO_MBC(x) != BLK_TO_MBC(res) || x_sz == y_sz) {
+			if (x < res) {
+			    res = x;
+			}
+		    }
+		    else if (x_sz < y_sz) {
+			res = x;
+		    }
+		    break;
 		}
+
 	    }
 	}
 
@@ -263,17 +297,20 @@ check_tree(TestCaseState_t *tcs, Allctr_t *alc, Ulong size)
 }
 
 static void
-do_check(TestCaseState_t *tcs, Allctr_t *a, Ulong size)
+do_check(TestCaseState_t *tcs, Allctr_t *a, Ulong size, int ignore_null)
 {
     Ulong sz = ((size + 7) / 8)*8;
     void *tmp;
     Block_t *x, *y;
 
     x = (Block_t *) check_tree(tcs, a, sz);
+    if (!x && ignore_null)
+	return;
+
     tmp = ALLOC(a, sz - ABLK_HDR_SZ);
     ASSERT(tcs, tmp);
     y = UMEM2BLK(tmp);
-    if (IS_AOBF(a)) {
+    if (!(IS_BF_ALGO(a) && !IS_AOBF(a))) {
 	ASSERT(tcs, x == y);
     }
     else {
@@ -306,7 +343,7 @@ test_it(TestCaseState_t *tcs)
 	    blk[i] = NULL;
 	}
 	if (i % (NO_BLOCKS/2) == 0)
-	    do_check(tcs, a, 50);
+	    do_check(tcs, a, 50, 0);
     }
 
     for (i = 0; i < NO_BLOCKS; i++) {
@@ -315,7 +352,7 @@ test_it(TestCaseState_t *tcs)
 	    blk[i] = NULL;
 	}
 	if (i % (NO_BLOCKS/2) == 0)
-	    do_check(tcs, a, 200);
+	    do_check(tcs, a, 200, 0);
     }
 
     for (i = 0; i < NO_BLOCKS; i++) {
@@ -324,20 +361,101 @@ test_it(TestCaseState_t *tcs)
 	    blk[i] = NULL;
 	}
 	if (i % (NO_BLOCKS/2) == 0)
-	    do_check(tcs, a, 100);
+	    do_check(tcs, a, 100, 0);
     }
 
-    do_check(tcs, a, 250);
+    do_check(tcs, a, 250, 0);
 
     for (i = 0; i < NO_BLOCKS; i++) {
 	FREE(a, fence[i]);
 	if (i % (NO_BLOCKS/3) == 0)
-	    do_check(tcs, a, 300);
+	    do_check(tcs, a, 300, 0);
+    }
+
+    ASSERT(tcs, RBT_ROOT(a,0));
+    ASSERT(tcs, !RBT_LEFT(RBT_ROOT(a,0)));
+    ASSERT(tcs, !RBT_RIGHT(RBT_ROOT(a,0)));
+}
+
+
+static int is_single_ablk_in_mbc(Allctr_t* a, void* ptr, void* crr)
+{
+    Block_t* blk = UMEM2BLK(ptr);
+    if (crr == BLK_TO_MBC(blk)) {
+	Block_t* first = MBC_TO_FIRST_BLK(a, crr);
+	if (blk == first || (IS_FREE_BLK(first) && blk == NXT_BLK(first))) {
+	    Block_t* nxt;
+	    if (IS_LAST_BLK(blk)) {
+		return 1;
+	    }
+	    nxt = NXT_BLK(blk);
+	    return IS_FREE_BLK(nxt) && IS_LAST_BLK(nxt);
+	}
+    }
+    return 0;
+}
+
+static void
+test_carrier_migration(TestCaseState_t *tcs)
+{
+    int i, j;
+    Allctr_t* a = ((rbtree_test_data *) tcs->extra)->allocator;
+    void **blk = ((rbtree_test_data *) tcs->extra)->blk;
+    void **fence = ((rbtree_test_data *) tcs->extra)->fence;
+    void *crr, *p, *free_crr;
+    Ulong min_blk_sz;
+
+    min_blk_sz = MIN_BLK_SZ(a);
+
+    for (i = 0; i < NO_BLOCKS; i++) {
+	blk[i] = ALLOC(a, min_blk_sz + i % 500);
+	fence[i] = ALLOC(a, 1);
+	ASSERT(tcs, blk[i] && fence[i]);
+    }
+
+    for (j = 0; j < NO_BLOCKS; j += 997) {
+	crr = BLK_TO_MBC(UMEM2BLK(blk[j]));
+	REMOVE_MBC(a, crr);
+
+	for (i = 0; i < NO_BLOCKS; i++) {
+	    if (i % 3 == 0) {
+		if (is_single_ablk_in_mbc(a, blk[i], crr)) {
+		    crr = NULL; /* about to destroy the removed mbc */
+		}
+		FREE(a, blk[i]);
+		blk[i] = NULL;
+	    }
+	    if (i % (NO_BLOCKS/2) == 0)
+		do_check(tcs, a, 50, 1);
+	}
+	
+	for (i = 0; i < NO_BLOCKS; i++) {
+	    if (i % 3 == 0) {
+		ASSERT(tcs, !blk[i]);
+		blk[i] = ALLOC(a, min_blk_sz + i % 500);
+		ASSERT(tcs, BLK_TO_MBC(UMEM2BLK(blk[i])) != crr);
+	    }
+	    if (i % (NO_BLOCKS/2) == 0)
+		do_check(tcs, a, 50, 1);
+	}
+	if (crr) {
+	    ADD_MBC(a, crr);
+	}
+    }
+	
+    for (crr = FIRST_MBC(a); crr; crr = NEXT_C(crr)) {
+	REMOVE_MBC(a, crr);
     }
 
-    ASSERT(tcs, RBT_ROOT(a));
-    ASSERT(tcs, !RBT_LEFT(RBT_ROOT(a)));
-    ASSERT(tcs, !RBT_RIGHT(RBT_ROOT(a)));
+    p = ALLOC(a, 1);
+    free_crr = BLK_TO_MBC(UMEM2BLK(p));
+    FREE(a, p);
+
+    for (crr = FIRST_MBC(a); crr; crr = NEXT_C(crr)) {
+	ASSERT(tcs, free_crr != crr);
+    }
+
+    ASSERT(tcs, !RBT_ROOT(a,0));
 }
 
 
@@ -369,6 +487,7 @@ testcase_run(TestCaseState_t *tcs)
     char *argv1[] = {"-tasbf", NULL};
     char *argv2[] = {"-tasaobf", NULL};
     char *argv3[] = {"-tasaoff", NULL};
+    char *argv4[] = {"-tasaoffcaobf", NULL};
     Allctr_t *a;
     rbtree_test_data *td;
 
@@ -390,6 +509,7 @@ testcase_run(TestCaseState_t *tcs)
     td->allocator = a = START_ALC("rbtree_bf_", 0, argv1);
 
     ASSERT(tcs, a);
+    ASSERT(tcs, IS_BF_ALGO(a));
     ASSERT(tcs, !IS_AOBF(a));
 
     test_it(tcs);
@@ -407,6 +527,7 @@ testcase_run(TestCaseState_t *tcs)
     td->allocator = a = START_ALC("rbtree_aobf_", 0, argv2);
 
     ASSERT(tcs, a);
+    ASSERT(tcs, IS_BF_ALGO(a));
     ASSERT(tcs, IS_AOBF(a));
 
     test_it(tcs);
@@ -424,11 +545,34 @@ testcase_run(TestCaseState_t *tcs)
     td->allocator = a = START_ALC("rbtree_aoff_", 0, argv3);
 
     ASSERT(tcs, a);
+    ASSERT(tcs, !IS_BF_ALGO(a));
+    ASSERT(tcs, !IS_CBF(a));
 
     test_it(tcs);
+    test_carrier_migration(tcs);
 
     STOP_ALC(a);
     td->allocator = NULL;
 
     testcase_printf(tcs, "Address order first fit test succeeded!\n");
+
+    /* Address order first fit, best fit within carrier */
+
+    testcase_printf(tcs, "Starting test of aoffcaobf...\n");
+
+    current_rbt_type_op_base = AO_FIRSTFIT_OP_BASE;
+    td->allocator = a = START_ALC("rbtree_aoffcaobf_", 0, argv4);
+
+    ASSERT(tcs, a);
+    ASSERT(tcs, !IS_BF_ALGO(a));
+    ASSERT(tcs, IS_CBF(a));
+
+    test_it(tcs);
+    test_carrier_migration(tcs);
+
+    STOP_ALC(a);
+    td->allocator = NULL;
+
+    testcase_printf(tcs, "aoffcaobf test succeeded!\n");
+
 }
diff --git a/erts/emulator/test/driver_SUITE.erl b/erts/emulator/test/driver_SUITE.erl
index dfba7d098f..104bdf8aec 100644
--- a/erts/emulator/test/driver_SUITE.erl
+++ b/erts/emulator/test/driver_SUITE.erl
@@ -2582,10 +2582,9 @@ driver_alloc_size() ->
 	MemInfo ->
 	    CS = lists:foldl(
 		   fun ({instance, _, L}, Acc) ->
-			   {value,{_,SBMBCS}} = lists:keysearch(sbmbcs, 1, L),
 			   {value,{_,MBCS}} = lists:keysearch(mbcs, 1, L),
 			   {value,{_,SBCS}} = lists:keysearch(sbcs, 1, L),
-			   [SBMBCS,MBCS,SBCS | Acc]
+			   [MBCS,SBCS | Acc]
 		   end,
 		   [],
 		   MemInfo),
diff --git a/erts/emulator/test/nif_SUITE.erl b/erts/emulator/test/nif_SUITE.erl
index dcf58fa474..9a70e8646a 100644
--- a/erts/emulator/test/nif_SUITE.erl
+++ b/erts/emulator/test/nif_SUITE.erl
@@ -1368,10 +1368,9 @@ tmpmem() ->
 	MemInfo ->
 	    MSBCS = lists:foldl(
 		      fun ({instance, _, L}, Acc) ->
-			      {value,{_,SBMBCS}} = lists:keysearch(sbmbcs, 1, L),
 			      {value,{_,MBCS}} = lists:keysearch(mbcs, 1, L),
 			      {value,{_,SBCS}} = lists:keysearch(sbcs, 1, L),
-			      [SBMBCS,MBCS,SBCS | Acc]
+			      [MBCS,SBCS | Acc]
 		      end,
 		      [],
 		      MemInfo),
diff --git a/erts/emulator/test/send_term_SUITE.erl b/erts/emulator/test/send_term_SUITE.erl
index ba0ba804ca..6615873392 100644
--- a/erts/emulator/test/send_term_SUITE.erl
+++ b/erts/emulator/test/send_term_SUITE.erl
@@ -175,10 +175,6 @@ chk_temp_alloc() ->
 	    %% Verify that we havn't got anything allocated by temp_alloc
 	    lists:foreach(
 	      fun ({instance, _, TI}) ->
-		      ?line {value, {sbmbcs, SBMBCInfo}}
-			  = lists:keysearch(sbmbcs, 1, TI),
-		      ?line {value, {blocks, 0, _, _}}
-			  = lists:keysearch(blocks, 1, SBMBCInfo),
 		      ?line {value, {mbcs, MBCInfo}}
 			  = lists:keysearch(mbcs, 1, TI),
 		      ?line {value, {blocks, 0, _, _}}