erts: Remove SBMBC allocator

20 files changed, 84 insertions, 535 deletions

diff --git a/erts/doc/src/erts_alloc.xml b/erts/doc/src/erts_alloc.xml
index c73cdfd290..a95b5d7cc4 100644
--- a/erts/doc/src/erts_alloc.xml
+++ b/erts/doc/src/erts_alloc.xml
@@ -75,10 +75,6 @@
        segments are allocated, cached segments are used if possible
        instead of creating new segments.  This in order to reduce
        the number of system calls made.</item>
-      <tag><c>sbmbc_alloc</c></tag>
-      <item>Allocator used by other allocators for allocation of carriers
-      where only small blocks are placed. Currently this allocator is
-      disabled by default.</item>
     </taglist>
     <p><c>sys_alloc</c> is always enabled and
       cannot be disabled. <c>mseg_alloc</c> is always enabled if it is
@@ -86,9 +82,7 @@
       allocators can be <seealso marker="#M_e">enabled or disabled</seealso>.
       By default all allocators are enabled.
       When an allocator is disabled, <c>sys_alloc</c> is used instead of
-      the disabled allocator. <c>sbmbc_alloc</c> is an exception. If
-      <c>sbmbc_alloc</c> is disabled, other allocators will not handle
-      small blocks in separate carriers.</p>
+      the disabled allocator.</p>
     <p>The main idea with the <c>erts_alloc</c> library is to separate
       memory blocks that are used differently into different memory
       areas, and by this achieving less memory fragmentation. By
@@ -106,20 +100,15 @@
       following does <em>not</em> apply to them.</p>
     <p>An allocator manages multiple areas, called carriers, in which
       memory blocks are placed. A carrier is either placed in a
-      separate memory segment (allocated via <c>mseg_alloc</c>), in
-      the heap segment (allocated via <c>sys_alloc</c>), or inside
-      another carrier (in case it is a carrier created by
-      <c>sbmbc_alloc</c>). Multiblock
+      separate memory segment (allocated via <c>mseg_alloc</c>), or in
+      the heap segment (allocated via <c>sys_alloc</c>). Multiblock
       carriers are used for storage of several blocks. Singleblock
       carriers are used for storage of one block. Blocks that are
       larger than the value of the singleblock carrier threshold
       (<seealso marker="#M_sbct">sbct</seealso>) parameter are placed
       in singleblock carriers. Blocks that are smaller than the value
       of the <c>sbct</c> parameter are placed in multiblock
-      carriers. Blocks that are smaller than the small block multiblock
-      carrier threshold (<seealso marker="#M_sbmbct">sbmbct</seealso>)
-      will be placed in multiblock carriers only used for small blocks.
-      Normally an allocator creates a "main multiblock
+      carriers. Normally an allocator creates a "main multiblock
       carrier". Main multiblock carriers are never deallocated. The
       size of the main multiblock carrier is determined by the value
       of the <seealso marker="#M_mmbcs">mmbcs</seealso> parameter.</p>
@@ -140,9 +129,7 @@
       <c>sbct</c> parameter should be larger than the value of the
       <c>lmbcs</c> parameter, the allocator may have to create
       multiblock carriers that are larger than the value of the
-      <c>lmbcs</c> parameter, though. The size of multiblock carriers
-      for small blocks is determined by the small block multiblock
-      carrier size (<seealso marker="#M_sbmbcs">sbmbcs</seealso>).
+      <c>lmbcs</c> parameter, though.
       Singleblock carriers allocated via <c>mseg_alloc</c> are sized
       to whole pages.</p>
     <p>Sizes of carriers allocated via <c>sys_alloc</c> are
@@ -219,11 +206,6 @@
        but can only satisfy a limited amount of requests.</p>
   </section>
 
-  <note><p>
-    Currently only allocators using the best fit and the address order
-    best fit strategies are able to use "small block multi block carriers".
-  </p></note>
-
   <section>
     <marker id="flags"></marker>
     <title>System Flags Effecting erts_alloc</title>
@@ -245,7 +227,6 @@
       the currently present allocators:</p>
     <list type="bulleted">
       <item><c>B: binary_alloc</c></item>
-      <item><c>C: sbmbc_alloc</c></item>
       <item><c>D: std_alloc</c></item>
       <item><c>E: ets_alloc</c></item>
       <item><c>F: fix_alloc</c></item>
@@ -416,20 +397,6 @@
        smaller than this threshold will be placed in multiblock
        carriers. On 32-bit Unix style OS this threshold can not be set higher
        than 8 megabytes.</item>
-      <tag><marker id="M_sbmbcs"><c><![CDATA[+M<S>sbmbcs <size>]]></c></marker></tag>
-      <item>
-	Small block multiblock carrier size (in bytes). Memory blocks smaller
-	than the small block multiblock carrier threshold
-	(<seealso marker="#M_sbmbct">sbmbct</seealso>) will be placed in
-	multiblock carriers used for small blocks only. This parameter
-	determines the size of such carriers.
-      </item>
-      <tag><marker id="M_sbmbct"><c><![CDATA[+M<S>sbmbct <size>]]></c></marker></tag>
-      <item>
-	Small block multiblock carrier threshold (in bytes). Memory blocks
-	smaller than this threshold will be placed in multiblock carriers
-	used for small blocks only.
-      </item>
       <tag><marker id="M_smbcs"><c><![CDATA[+M<S>smbcs <size>]]></c></marker></tag>
       <item>
        Smallest (<c>mseg_alloc</c>) multiblock carrier size (in
diff --git a/erts/emulator/beam/erl_afit_alloc.c b/erts/emulator/beam/erl_afit_alloc.c
index 608a4dd26d..84aab68f7d 100644
--- a/erts/emulator/beam/erl_afit_alloc.c
+++ b/erts/emulator/beam/erl_afit_alloc.c
@@ -84,8 +84,6 @@ erts_afalc_start(AFAllctr_t *afallctr,
 
     sys_memcpy((void *) afallctr, (void *) &zero.allctr, sizeof(AFAllctr_t));
 
-    init->sbmbct = 0; /* Small mbc not supported by afit */
-
     allctr->mbc_header_size		= sizeof(Carrier_t);
     allctr->min_mbc_size		= MIN_MBC_SZ;
     allctr->min_mbc_first_free_size	= MIN_MBC_FIRST_FREE_SZ;
diff --git a/erts/emulator/beam/erl_alloc.c b/erts/emulator/beam/erl_alloc.c
index cb69be33ad..d45cd48623 100644
--- a/erts/emulator/beam/erl_alloc.c
+++ b/erts/emulator/beam/erl_alloc.c
@@ -101,11 +101,9 @@ typedef union {
     char align_aoffa[ERTS_ALC_CACHE_LINE_ALIGN_SIZE(sizeof(AOFFAllctr_t))];
 } ErtsAllocatorState_t;
 
-static ErtsAllocatorState_t sbmbc_alloc_state;
 static ErtsAllocatorState_t std_alloc_state;
 static ErtsAllocatorState_t ll_alloc_state;
 #if HALFWORD_HEAP
-static ErtsAllocatorState_t sbmbc_low_alloc_state;
 static ErtsAllocatorState_t std_low_alloc_state;
 static ErtsAllocatorState_t ll_low_alloc_state;
 #endif
@@ -200,7 +198,6 @@ typedef struct {
 	char *mtrace;
 	char *nodename;
     } instr;
-    struct au_init sbmbc_alloc;
     struct au_init sl_alloc;
     struct au_init std_alloc;
     struct au_init ll_alloc;
@@ -211,7 +208,6 @@ typedef struct {
     struct au_init driver_alloc;
     struct au_init fix_alloc;
 #if HALFWORD_HEAP
-    struct au_init sbmbc_low_alloc;
     struct au_init std_low_alloc;
     struct au_init ll_low_alloc;
 #endif
@@ -226,34 +222,6 @@ do {									\
 } while (0)
 
 static void
-set_default_sbmbc_alloc_opts(struct au_init *ip)
-{
-    SET_DEFAULT_ALLOC_OPTS(ip);
-    ip->enable			= 0;
-    ip->thr_spec		= 0;
-    ip->atype			= BESTFIT;
-    ip->init.bf.ao		= 1;
-    ip->init.util.ramv		= 0;
-    ip->init.util.mmsbc		= 0;
-    ip->init.util.mmmbc		= 500;
-    ip->init.util.sbct		= ~((UWord) 0);
-    ip->init.util.name_prefix	= "sbmbc_";
-    ip->init.util.alloc_no	= ERTS_ALC_A_SBMBC;
-#ifndef SMALL_MEMORY
-    ip->init.util.mmbcs 	= 2*1024*1024; /* Main carrier size */
-#else
-    ip->init.util.mmbcs 	= 1*1024*1024; /* Main carrier size */
-#endif
-    ip->init.util.ts 		= ERTS_ALC_MTA_SBMBC;
-    ip->init.util.asbcst	= 0;
-    ip->init.util.rsbcst	= 0;
-    ip->init.util.rsbcmt	= 0;
-    ip->init.util.rmbcmt	= 0;
-    ip->init.util.sbmbct	= 0;
-    ip->init.util.sbmbcs	= 0;
-}
-
-static void
 set_default_sl_alloc_opts(struct au_init *ip)
 {
     SET_DEFAULT_ALLOC_OPTS(ip);
@@ -319,8 +287,6 @@ set_default_ll_alloc_opts(struct au_init *ip)
     ip->init.util.rsbcst	= 0;
     ip->init.util.rsbcmt	= 0;
     ip->init.util.rmbcmt	= 0;
-    ip->init.util.sbmbct	= 0;
-    ip->init.util.sbmbcs	= 0;
 }
 
 static void
@@ -565,7 +531,6 @@ erts_alloc_init(int *argc, char **argv, ErtsAllocInitOpts *eaiop)
     hdbg_init();
 #endif
 
-    erts_have_sbmbc_alloc = 0;
     ncpu = eaiop->ncpu;
     if (ncpu < 1)
 	ncpu = 1;
@@ -575,7 +540,6 @@ erts_alloc_init(int *argc, char **argv, ErtsAllocInitOpts *eaiop)
     erts_sys_alloc_init();
     erts_init_utils_mem();
 
-    set_default_sbmbc_alloc_opts(&init.sbmbc_alloc);
     set_default_sl_alloc_opts(&init.sl_alloc);
     set_default_std_alloc_opts(&init.std_alloc);
     set_default_ll_alloc_opts(&init.ll_alloc);
@@ -591,7 +555,6 @@ erts_alloc_init(int *argc, char **argv, ErtsAllocInitOpts *eaiop)
 	handle_args(argc, argv, &init);
 
 #ifndef ERTS_SMP
-    init.sbmbc_alloc.thr_spec = 0;
     init.sl_alloc.thr_spec = 0;
     init.std_alloc.thr_spec = 0;
     init.ll_alloc.thr_spec = 0;
@@ -604,7 +567,6 @@ erts_alloc_init(int *argc, char **argv, ErtsAllocInitOpts *eaiop)
 
     if (init.erts_alloc_config) {
 	/* Adjust flags that erts_alloc_config won't like */
-	init.sbmbc_alloc.thr_spec = 0;
 	init.temp_alloc.thr_spec = 0;
 	init.sl_alloc.thr_spec = 0;
 	init.std_alloc.thr_spec = 0;
@@ -622,7 +584,6 @@ erts_alloc_init(int *argc, char **argv, ErtsAllocInitOpts *eaiop)
 	init.temp_alloc.thr_spec = erts_no_schedulers;
 
     /* Others must use thread preferred interface */
-    adjust_tpref(&init.sbmbc_alloc, erts_no_schedulers);
     adjust_tpref(&init.sl_alloc, erts_no_schedulers);
     adjust_tpref(&init.std_alloc, erts_no_schedulers);
     adjust_tpref(&init.ll_alloc, erts_no_schedulers);
@@ -641,7 +602,6 @@ erts_alloc_init(int *argc, char **argv, ErtsAllocInitOpts *eaiop)
      * The following allocators cannot be run with afit strategy.
      * Make sure they don't...
      */
-    refuse_af_strategy(&init.sbmbc_alloc);
     refuse_af_strategy(&init.sl_alloc);
     refuse_af_strategy(&init.std_alloc);
     refuse_af_strategy(&init.ll_alloc);
@@ -685,11 +645,6 @@ erts_alloc_init(int *argc, char **argv, ErtsAllocInitOpts *eaiop)
 
 #if HALFWORD_HEAP
     /* Init low memory variants by cloning */
-    init.sbmbc_low_alloc = init.sbmbc_alloc;
-    init.sbmbc_low_alloc.init.util.name_prefix = "sbmbc_low_";
-    init.sbmbc_low_alloc.init.util.alloc_no = ERTS_ALC_A_SBMBC_LOW;
-    init.sbmbc_low_alloc.init.util.low_mem = 1;
-
     init.std_low_alloc = init.std_alloc;
     init.std_low_alloc.init.util.name_prefix	= "std_low_";
     init.std_low_alloc.init.util.alloc_no = ERTS_ALC_A_STANDARD_LOW;
@@ -702,13 +657,11 @@ erts_alloc_init(int *argc, char **argv, ErtsAllocInitOpts *eaiop)
     init.ll_low_alloc.init.util.force = 1;
     init.ll_low_alloc.init.util.low_mem = 1;
 
-    set_au_allocator(ERTS_ALC_A_SBMBC_LOW, &init.sbmbc_low_alloc, ncpu);
     set_au_allocator(ERTS_ALC_A_STANDARD_LOW, &init.std_low_alloc, ncpu);
     set_au_allocator(ERTS_ALC_A_LONG_LIVED_LOW, &init.ll_low_alloc, ncpu);
 #endif /* HALFWORD */
 
     set_au_allocator(ERTS_ALC_A_TEMPORARY, &init.temp_alloc, ncpu);
-    set_au_allocator(ERTS_ALC_A_SBMBC, &init.sbmbc_alloc, ncpu);
     set_au_allocator(ERTS_ALC_A_SHORT_LIVED, &init.sl_alloc, ncpu);
     set_au_allocator(ERTS_ALC_A_STANDARD, &init.std_alloc, ncpu);
     set_au_allocator(ERTS_ALC_A_LONG_LIVED, &init.ll_alloc, ncpu);
@@ -735,20 +688,6 @@ erts_alloc_init(int *argc, char **argv, ErtsAllocInitOpts *eaiop)
 
     erts_mtrace_init(init.instr.mtrace, init.instr.nodename);
 
-    /* sbmbc_alloc() needs to be started first */
-    start_au_allocator(ERTS_ALC_A_SBMBC,
-		       &init.sbmbc_alloc,
-		       &sbmbc_alloc_state);
-#if HALFWORD_HEAP
-    start_au_allocator(ERTS_ALC_A_SBMBC_LOW,
-		       &init.sbmbc_low_alloc,
-		       &sbmbc_low_alloc_state);
-    erts_have_sbmbc_alloc = (init.sbmbc_alloc.enable
-			     && init.sbmbc_low_alloc.enable);
-#else
-    erts_have_sbmbc_alloc = init.sbmbc_alloc.enable;
-#endif
-
     start_au_allocator(ERTS_ALC_A_TEMPORARY,
 		       &init.temp_alloc,
 		       &temp_alloc_state);
@@ -1138,6 +1077,7 @@ get_kb_value(char *param_end, char** argv, int* ip)
 	return ((Uint) tmp)*1024;
 }
 
+#if 0
 static Uint
 get_byte_value(char *param_end, char** argv, int* ip)
 {
@@ -1151,6 +1091,7 @@ get_byte_value(char *param_end, char** argv, int* ip)
 	bad_value(param, param_end, value);
     return (Uint) tmp;
 }
+#endif
 
 static Uint
 get_amount_value(char *param_end, char** argv, int* ip)
@@ -1212,11 +1153,6 @@ handle_au_arg(struct au_init *auip,
 	break;
     case 'e':
 	auip->enable = get_bool_value(sub_param+1, argv, ip);
-#if !HAVE_ERTS_SBMBC
-	if (auip->init.util.alloc_no == ERTS_ALC_A_SBMBC) {
-	    auip->enable = 0;
-	}
-#endif
 	break;
     case 'l':
 	if (has_prefix("lmbcs", sub_param)) {
@@ -1276,18 +1212,6 @@ handle_au_arg(struct au_init *auip,
 	if(has_prefix("sbct", sub_param)) {
 	    auip->init.util.sbct = get_kb_value(sub_param + 4, argv, ip);
 	}
-	else if (has_prefix("sbmbcs", sub_param)) {
-#if HAVE_ERTS_SBMBC
-	    auip->init.util.sbmbcs =
-#endif
-		get_byte_value(sub_param + 6, argv, ip);
-	}
-	else if (has_prefix("sbmbct", sub_param)) {
-#if HAVE_ERTS_SBMBC
-	    auip->init.util.sbmbct =
-#endif
-		get_byte_value(sub_param + 6, argv, ip);
-	}
 	else if (has_prefix("smbcs", sub_param)) {
 	    auip->default_.smbcs = 0;
 	    auip->init.util.smbcs = get_kb_value(sub_param + 5, argv, ip);
@@ -1317,7 +1241,6 @@ static void
 handle_args(int *argc, char **argv, erts_alc_hndl_args_init_t *init)
 {
     struct au_init *aui[] = {
-	&init->sbmbc_alloc,
 	&init->binary_alloc,
 	&init->std_alloc,
 	&init->ets_alloc,
@@ -1346,9 +1269,6 @@ handle_args(int *argc, char **argv, erts_alc_hndl_args_init_t *init)
 		case 'B':
 		    handle_au_arg(&init->binary_alloc, &argv[i][3], argv, &i);
 		    break;
-		case 'C':
-		    handle_au_arg(&init->sbmbc_alloc, &argv[i][3], argv, &i);
-		    break;
 		case 'D':
 		    handle_au_arg(&init->std_alloc, &argv[i][3], argv, &i);
 		    break;
@@ -1453,9 +1373,6 @@ handle_args(int *argc, char **argv, erts_alc_hndl_args_init_t *init)
 			else if (strcmp("max", arg) == 0) {
 			    for (a = 0; a < aui_sz; a++)
 				aui[a]->enable = 1;
-#if !HAVE_ERTS_SBMBC
-			    init->sbmbc_alloc.enable = 0;
-#endif
 			}
 			else if (strcmp("config", arg) == 0) {
 			    init->erts_alloc_config = 1;
@@ -2093,15 +2010,11 @@ erts_memory(int *print_to_p, void *print_to_arg, void *proc, Eterm earg)
 	    return am_badarg;
     }
 
-    /* All alloc_util allocators except sbmbc_alloc *have* to be enabled */
+    /* All alloc_util allocators *have* to be enabled */
     
     for (ai = ERTS_ALC_A_MIN; ai <= ERTS_ALC_A_MAX; ai++) {
 	switch (ai) {
 	case ERTS_ALC_A_SYSTEM:
-	case ERTS_ALC_A_SBMBC:
-#if HALFWORD_HEAP
-	case ERTS_ALC_A_SBMBC_LOW:
-#endif
 	    break;
 	default:
 	    if (!erts_allctrs_info[ai].enabled
@@ -2141,12 +2054,6 @@ erts_memory(int *print_to_p, void *print_to_arg, void *proc, Eterm earg)
 		      * Often not thread safe and usually never
 		      * contain any allocated memory.
 		      */
-		case ERTS_ALC_A_SBMBC:
-		    /* Included in other allocators */
-#if HALFWORD_HEAP
-		case ERTS_ALC_A_SBMBC_LOW:
-		    /* Included in other allocators */
-#endif
 		    continue;
 		case ERTS_ALC_A_EHEAP:
 		    save = &size.processes;
@@ -3278,7 +3185,6 @@ UWord erts_alc_test(UWord op, UWord a1, UWord a2, UWord a3)
 	    init.atype = GOODFIT;
 	    init.init.util.name_prefix = (char *) a1;
 	    init.init.util.ts = a2 ? 1 : 0;
-	    init.init.util.sbmbct = 0;
 
 	    if ((char **) a3) {
 		char **argv = (char **) a3;
diff --git a/erts/emulator/beam/erl_alloc.h b/erts/emulator/beam/erl_alloc.h
index 9cafd8ddc8..8c80cbb4cc 100644
--- a/erts/emulator/beam/erl_alloc.h
+++ b/erts/emulator/beam/erl_alloc.h
@@ -100,14 +100,6 @@ UWord erts_alc_test(UWord,
 
 #define ERTS_ALC_MIN_LONG_LIVED_TIME	(10*60*1000)
 
-#if HALFWORD_HEAP
-#define ERTS_IS_SBMBC_ALLOCATOR_NO__(NO) \
-  ((NO) == ERTS_ALC_A_SBMBC || (NO) == ERTS_ALC_A_SBMBC_LOW)
-#else
-#define ERTS_IS_SBMBC_ALLOCATOR_NO__(NO) \
-  ((NO) == ERTS_ALC_A_SBMBC)
-#endif
-
 typedef struct {
     int alloc_util;
     int enabled;
diff --git a/erts/emulator/beam/erl_alloc.types b/erts/emulator/beam/erl_alloc.types
index f913525726..095ad24387 100644
--- a/erts/emulator/beam/erl_alloc.types
+++ b/erts/emulator/beam/erl_alloc.types
@@ -76,11 +76,6 @@
 
 allocator	SYSTEM		true		sys_alloc
 
-allocator	SBMBC		true		sbmbc_alloc
-+if halfword
-allocator	SBMBC_LOW	true		sbmbc_low_alloc
-+endif
-
 +if smp
 
 allocator	TEMPORARY	true		temp_alloc
@@ -146,7 +141,6 @@ class	SYSTEM		system_data
 #
 #	<TYPE>		<ALLOCATOR>	<CLASS>		<DESCRIPTION>
 
-type	SBMBC		SBMBC		SYSTEM		small_block_mbc
 type	PROC		FIXED_SIZE	PROCESSES	proc
 type	PORT		DRIVER		SYSTEM		port
 type	ATOM		LONG_LIVED	ATOM		atom_entry
@@ -351,7 +345,6 @@ type	SSB		SHORT_LIVED	PROCESSES	ssb
 
 +if halfword
 
-type	SBMBC_LOW	SBMBC_LOW	SYSTEM		small_block_mbc_low
 type	DDLL_PROCESS	STANDARD_LOW	SYSTEM		ddll_processes
 type	MONITOR_LH	STANDARD_LOW	PROCESSES	monitor_lh
 type	NLINK_LH	STANDARD_LOW	PROCESSES	nlink_lh
diff --git a/erts/emulator/beam/erl_alloc_util.c b/erts/emulator/beam/erl_alloc_util.c
index 67cc4ae62a..67d973d07c 100644
--- a/erts/emulator/beam/erl_alloc_util.c
+++ b/erts/emulator/beam/erl_alloc_util.c
@@ -74,8 +74,6 @@
 static int atoms_initialized = 0;
 static int initialized = 0;
 
-int erts_have_sbmbc_alloc;
-
 
 #define INV_SYS_ALLOC_CARRIER_MASK	((UWord) (sys_alloc_carrier_size - 1))
 #define SYS_ALLOC_CARRIER_MASK		(~INV_SYS_ALLOC_CARRIER_MASK)
@@ -370,11 +368,7 @@ static void check_blk_carrier(Allctr_t *, Block_t *);
     ASSERT(((AP)->mbcs.curr.norm.sys_alloc.no				\
 	    && (AP)->mbcs.curr.norm.sys_alloc.size)			\
 	   || (!(AP)->mbcs.curr.norm.sys_alloc.no			\
-	       && !(AP)->mbcs.curr.norm.sys_alloc.size));		\
-    ASSERT(((AP)->sbmbcs.curr.small_block.no				\
-	    && (AP)->sbmbcs.curr.small_block.size)			\
-	   || (!(AP)->sbmbcs.curr.small_block.no			\
-	       && !(AP)->sbmbcs.curr.small_block.size))
+	       && !(AP)->mbcs.curr.norm.sys_alloc.size));
 
 #else
 #define DEBUG_CHECK_CARRIER_NO_SZ(AP)
@@ -445,17 +439,6 @@ do {									\
 			       + (AP)->mbcs.curr.norm.sys_alloc.size)
 
 
-#define STAT_SBMBC_ALLOC(AP, CSZ)					\
-do {									\
-    (AP)->sbmbcs.curr.small_block.no++;					\
-    (AP)->sbmbcs.curr.small_block.size += (CSZ);			\
-    if ((AP)->sbmbcs.max.no < (AP)->sbmbcs.curr.small_block.no)		\
-	(AP)->sbmbcs.max.no = (AP)->sbmbcs.curr.small_block.no;		\
-    if ((AP)->sbmbcs.max.size < (AP)->sbmbcs.curr.small_block.size)	\
-	(AP)->sbmbcs.max.size = (AP)->sbmbcs.curr.small_block.size;	\
-    DEBUG_CHECK_CARRIER_NO_SZ((AP));					\
-} while (0)
-
 #define STAT_MSEG_MBC_ALLOC(AP, CSZ)					\
 do {									\
     (AP)->mbcs.curr.norm.mseg.no++;					\
@@ -472,15 +455,6 @@ do {									\
     DEBUG_CHECK_CARRIER_NO_SZ((AP));					\
 } while (0)
 
-#define STAT_SBMBC_FREE(AP, CSZ)					\
-do {									\
-    ASSERT((AP)->sbmbcs.curr.small_block.no > 0);			\
-    (AP)->sbmbcs.curr.small_block.no--;					\
-    ASSERT((AP)->sbmbcs.curr.small_block.size >= (CSZ));		\
-    (AP)->sbmbcs.curr.small_block.size -= (CSZ);			\
-    DEBUG_CHECK_CARRIER_NO_SZ((AP));					\
-} while (0)
-
 #define STAT_MSEG_MBC_FREE(AP, CSZ)					\
 do {									\
     ASSERT((AP)->mbcs.curr.norm.mseg.no > 0);				\
@@ -501,9 +475,7 @@ do {									\
 
 #define STAT_MBC_BLK_ALLOC(AP, BSZ, FLGS)	       			\
 do {									\
-    CarriersStats_t *cstats__ = (((FLGS) & ERTS_ALCU_FLG_SBMBC)		\
-				 ? &(AP)->sbmbcs			\
-				 : &(AP)->mbcs);			\
+    CarriersStats_t *cstats__ = &(AP)->mbcs;			        \
     cstats__->blocks.curr.no++;						\
     if (cstats__->blocks.max.no < cstats__->blocks.curr.no)		\
 	cstats__->blocks.max.no = cstats__->blocks.curr.no;		\
@@ -514,9 +486,7 @@ do {									\
 
 #define STAT_MBC_BLK_FREE(AP, BSZ, FLGS)				\
 do {									\
-    CarriersStats_t *cstats__ = (((FLGS) & ERTS_ALCU_FLG_SBMBC)		\
-				 ? &(AP)->sbmbcs			\
-				 : &(AP)->mbcs);			\
+    CarriersStats_t *cstats__ = &(AP)->mbcs;			        \
     ASSERT(cstats__->blocks.curr.no > 0);				\
     cstats__->blocks.curr.no--;						\
     ASSERT(cstats__->blocks.curr.size >= (BSZ));			\
@@ -739,8 +709,6 @@ unlink_carrier(CarrierList_t *cl, Carrier_t *crr)
     }
 }
 
-static Block_t *create_sbmbc(Allctr_t *allctr, Uint umem_sz);
-static void destroy_sbmbc(Allctr_t *allctr, Block_t *blk);
 static Block_t *create_carrier(Allctr_t *, Uint, UWord);
 static void destroy_carrier(Allctr_t *, Block_t *);
 
@@ -1246,25 +1214,12 @@ mbc_alloc_block(Allctr_t *allctr, Uint size, Uint *blk_szp, Uint32 *alcu_flgsp)
 {
     Block_t *blk;
     Uint get_blk_sz;
-    Uint sbmbct;
 
     ASSERT(size);
     ASSERT(size < allctr->sbc_threshold);
 
     *blk_szp = get_blk_sz = UMEMSZ2BLKSZ(allctr, size);
 
-    sbmbct = allctr->sbmbc_threshold;
-    if (sbmbct) {
-	if (get_blk_sz < sbmbct) {
-	    *alcu_flgsp |= ERTS_ALCU_FLG_SBMBC;
-	    if (get_blk_sz + allctr->min_block_size > sbmbct) {
-		/* Since we use block size to determine if blocks are
-		   located in sbmbc or not... */
-		get_blk_sz += allctr->min_block_size;
-	    }
-	}
-    }
-
 #ifdef ERTS_SMP
     if (allctr->dd.use)
 	ERTS_ALCU_HANDLE_DD_IN_OP(allctr, 1);
@@ -1281,22 +1236,18 @@ mbc_alloc_block(Allctr_t *allctr, Uint size, Uint *blk_szp, Uint32 *alcu_flgsp)
 #endif
 
     if (!blk) {
-	if ((*alcu_flgsp) & ERTS_ALCU_FLG_SBMBC) 
-	    blk = create_sbmbc(allctr, get_blk_sz);
-	else {
-	    blk = create_carrier(allctr, get_blk_sz, CFLG_MBC);
+	blk = create_carrier(allctr, get_blk_sz, CFLG_MBC);
 #if !HALFWORD_HEAP && !HAVE_SUPER_ALIGNED_MB_CARRIERS
-	    if (!blk) {
-		/* Emergency! We couldn't create the carrier as we wanted.
-		   Try to place it in a sys_alloced sbc. */
-		blk = create_carrier(allctr,
-				     size,
-				     (CFLG_SBC
-				      | CFLG_FORCE_SIZE
-				      | CFLG_FORCE_SYS_ALLOC));
-	    }
-#endif
+	if (!blk) {
+	    /* Emergency! We couldn't create the carrier as we wanted.
+	       Try to place it in a sys_alloced sbc. */
+	    blk = create_carrier(allctr,
+				 size,
+				 (CFLG_SBC
+				  | CFLG_FORCE_SIZE
+				  | CFLG_FORCE_SYS_ALLOC));
 	}
+#endif
     }
 
 #ifdef ERTS_ALLOC_UTIL_HARD_DEBUG
@@ -1442,8 +1393,6 @@ mbc_free(Allctr_t *allctr, void *p)
 
     blk = UMEM2BLK(p);
     blk_sz = MBC_ABLK_SZ(blk);
-    if (blk_sz < allctr->sbmbc_threshold)
-	alcu_flgs |= ERTS_ALCU_FLG_SBMBC;
 
     ASSERT(IS_MBC_BLK(blk));
     ASSERT(blk_sz >= allctr->min_block_size);
@@ -1508,10 +1457,7 @@ mbc_free(Allctr_t *allctr, void *p)
     if (is_first_blk
 	&& is_last_blk
 	&& allctr->main_carrier != FIRST_BLK_TO_MBC(allctr, blk)) {
-	if (alcu_flgs & ERTS_ALCU_FLG_SBMBC)
-	    destroy_sbmbc(allctr, blk);
-	else
-	    destroy_carrier(allctr, blk);
+	destroy_carrier(allctr, blk);
     }
     else {
 	(*allctr->link_free_block)(allctr, blk, alcu_flgs);
@@ -1553,12 +1499,6 @@ mbc_realloc(Allctr_t *allctr, void *p, Uint size, Uint32 alcu_flgs)
 	return NULL;
 #else /* !MBC_REALLOC_ALWAYS_MOVES */
     get_blk_sz = blk_sz = UMEMSZ2BLKSZ(allctr, size);
-    if ((alcu_flgs & ERTS_ALCU_FLG_SBMBC)
-	&& (blk_sz + allctr->min_block_size > allctr->sbmbc_threshold)) {
-	/* Since we use block size to determine if blocks are
-	   located in sbmbc or not... */
-	get_blk_sz = blk_sz + allctr->min_block_size;
-    }
 
     ASSERT(IS_ALLOCED_BLK(blk));
     ASSERT(IS_MBC_BLK(blk));
@@ -1932,81 +1872,6 @@ static void CHECK_1BLK_CARRIER(Allctr_t* A, int SBC, int MSEGED, Carrier_t* C,
 #endif
 
 static Block_t *
-create_sbmbc(Allctr_t *allctr, Uint umem_sz)
-{
-    Block_t *blk;
-    Uint blk_sz;
-    Uint crr_sz = allctr->sbmbc_size;
-    Carrier_t *crr;
-
-#if HALFWORD_HEAP
-    if (allctr->mseg_opt.low_mem)
-	crr = erts_alloc(ERTS_ALC_T_SBMBC_LOW, crr_sz);
-    else
-#endif
-	crr = erts_alloc(ERTS_ALC_T_SBMBC, crr_sz);
-
-    INC_CC(allctr->calls.sbmbc_alloc);
-    SET_CARRIER_HDR(crr, crr_sz, SCH_SYS_ALLOC|SCH_MBC, allctr);
-
-    blk = MBC_TO_FIRST_BLK(allctr, crr);
-
-    blk_sz = UNIT_FLOOR(crr_sz - MBC_HEADER_SIZE(allctr));
-
-    SET_MBC_FBLK_HDR(blk, blk_sz, SBH_THIS_FREE|SBH_LAST_BLK, crr);
-
-    link_carrier(&allctr->sbmbc_list, crr);
-
-    STAT_SBMBC_ALLOC(allctr, crr_sz);
-    CHECK_1BLK_CARRIER(allctr, 0, 0, crr, crr_sz, blk, blk_sz);
-    if (allctr->creating_mbc)
-	(*allctr->creating_mbc)(allctr, crr, ERTS_ALCU_FLG_SBMBC);
-
-    DEBUG_SAVE_ALIGNMENT(crr);
-    return blk;
-}
-
-static void
-destroy_sbmbc(Allctr_t *allctr, Block_t *blk)
-{
-    Uint crr_sz;
-    Carrier_t *crr;
-
-    ASSERT(IS_MBC_BLK(blk));
-    ASSERT(IS_MBC_FIRST_FBLK(allctr, blk));
-
-    crr = FIRST_BLK_TO_MBC(allctr, blk);
-    crr_sz = CARRIER_SZ(crr);
-
-#ifdef DEBUG
-    if (!allctr->stopped) {
-	ASSERT(IS_LAST_BLK(blk));
-
-#ifdef ERTS_ALLOC_UTIL_HARD_DEBUG
-	(*allctr->link_free_block)(allctr, blk, ERTS_ALCU_FLG_SBMBC);
-	HARD_CHECK_BLK_CARRIER(allctr, blk);
-	(*allctr->unlink_free_block)(allctr, blk, ERTS_ALCU_FLG_SBMBC);
-#endif
-    }
-#endif
-
-    STAT_SBMBC_FREE(allctr, crr_sz);
-
-    unlink_carrier(&allctr->sbmbc_list, crr);
-    if (allctr->destroying_mbc)
-	(*allctr->destroying_mbc)(allctr, crr, ERTS_ALCU_FLG_SBMBC);
-
-    INC_CC(allctr->calls.sbmbc_free);
-
-#if HALFWORD_HEAP
-    if (allctr->mseg_opt.low_mem)
-	erts_free(ERTS_ALC_T_SBMBC_LOW, crr);
-    else
-#endif
-	erts_free(ERTS_ALC_T_SBMBC, crr);
-}
-
-static Block_t *
 create_carrier(Allctr_t *allctr, Uint umem_sz, UWord flags)
 {
     Block_t *blk;
@@ -2415,16 +2280,12 @@ static struct {
     Eterm lmbcs;
     Eterm smbcs;
     Eterm mbcgs;
-    Eterm sbmbcs;
-    Eterm sbmbct;
 
 #if HAVE_ERTS_MSEG
     Eterm mmc;
 #endif
     Eterm ycs;
 
-    /* Eterm sbmbcs; */
-
     Eterm fix_types;
 
     Eterm mbcs;
@@ -2452,8 +2313,6 @@ static struct {
     Eterm mseg_dealloc;
     Eterm mseg_realloc;
 #endif
-    Eterm sbmbc_alloc;
-    Eterm sbmbc_free;
 #ifdef DEBUG
     Eterm end_of_atoms;
 #endif
@@ -2509,16 +2368,12 @@ init_atoms(Allctr_t *allctr)
 	AM_INIT(lmbcs);
 	AM_INIT(smbcs);
 	AM_INIT(mbcgs);
-	AM_INIT(sbmbcs);
-	AM_INIT(sbmbct);
 
 #if HAVE_ERTS_MSEG
 	AM_INIT(mmc);
 #endif
 	AM_INIT(ycs);
 
-	/*AM_INIT(sbmbcs);*/
-
 	AM_INIT(fix_types);
 
 	AM_INIT(mbcs);
@@ -2546,8 +2401,6 @@ init_atoms(Allctr_t *allctr)
 	AM_INIT(mseg_dealloc);
 	AM_INIT(mseg_realloc);
 #endif
-	AM_INIT(sbmbc_free);
-	AM_INIT(sbmbc_alloc);
 
 #ifdef DEBUG
 	for (atom = (Eterm *) &am; atom < &am.end_of_atoms; atom++) {
@@ -2685,9 +2538,7 @@ sz_info_carriers(Allctr_t *allctr,
 		 Uint *szp)
 {
     Eterm res = THE_NON_VALUE;
-    Uint curr_size = (cs == &allctr->sbmbcs
-		      ? cs->curr.small_block.size
-		      : cs->curr.norm.mseg.size + cs->curr.norm.sys_alloc.size);
+    Uint curr_size = cs->curr.norm.mseg.size + cs->curr.norm.sys_alloc.size;
 
     if (print_to_p) {
 	int to = *print_to_p;
@@ -2736,16 +2587,9 @@ info_carriers(Allctr_t *allctr,
 {
     Eterm res = THE_NON_VALUE;
     Uint curr_no, curr_size;
-    int small_block = cs == &allctr->sbmbcs;
-
-    if (small_block) {
-	curr_no = cs->curr.small_block.no;
-	curr_size = cs->curr.small_block.size;
-    }
-    else {
-	curr_no = cs->curr.norm.mseg.no + cs->curr.norm.sys_alloc.no;
-	curr_size = cs->curr.norm.mseg.size + cs->curr.norm.sys_alloc.size;
-    }
+    
+    curr_no = cs->curr.norm.mseg.no + cs->curr.norm.sys_alloc.no;
+    curr_size = cs->curr.norm.mseg.size + cs->curr.norm.sys_alloc.size;
 
     if (print_to_p) {
 	int to = *print_to_p;
@@ -2771,20 +2615,18 @@ info_carriers(Allctr_t *allctr,
 		   curr_no,
 		   cs->max.no,
 		   cs->max_ever.no);
-	if (!small_block) {
 #if HAVE_ERTS_MSEG
-	    erts_print(to,
-		       arg,
-		       "%smseg carriers: %bpu\n",
-		       prefix,
-		       cs->curr.norm.mseg.no);
+	erts_print(to,
+		   arg,
+		   "%smseg carriers: %bpu\n",
+		   prefix,
+		   cs->curr.norm.mseg.no);
 #endif
-	    erts_print(to,
-		       arg,
-		       "%ssys_alloc carriers: %bpu\n",
-		       prefix,
-		       cs->curr.norm.sys_alloc.no);
-	}
+	erts_print(to,
+		   arg,
+		   "%ssys_alloc carriers: %bpu\n",
+		   prefix,
+		   cs->curr.norm.sys_alloc.no);
 	erts_print(to,
 		   arg,
 		   "%scarriers size: %beu %bpu %bpu\n",
@@ -2792,49 +2634,43 @@ info_carriers(Allctr_t *allctr,
 		   curr_size,
 		   cs->max.size,
 		   cs->max_ever.size);
-	if (!small_block) {
 #if HAVE_ERTS_MSEG
-	    erts_print(to,
-		       arg,
-		       "%smseg carriers size: %bpu\n",
-		       prefix,
-		       cs->curr.norm.mseg.size);
+	erts_print(to,
+		   arg,
+		   "%smseg carriers size: %bpu\n",
+		   prefix,
+		   cs->curr.norm.mseg.size);
 #endif
-	    erts_print(to,
-		       arg,
-		       "%ssys_alloc carriers size: %bpu\n",
-		       prefix,
-		       cs->curr.norm.sys_alloc.size);
-	}
+	erts_print(to,
+		   arg,
+		   "%ssys_alloc carriers size: %bpu\n",
+		   prefix,
+		   cs->curr.norm.sys_alloc.size);
     }
 
     if (hpp || szp) {
 	res = NIL;
-	if (!small_block) {
-	    add_2tup(hpp, szp, &res,
-		     am.sys_alloc_carriers_size,
-		     bld_unstable_uint(hpp, szp, cs->curr.norm.sys_alloc.size));
+	add_2tup(hpp, szp, &res,
+		 am.sys_alloc_carriers_size,
+		 bld_unstable_uint(hpp, szp, cs->curr.norm.sys_alloc.size));
 #if HAVE_ERTS_MSEG
-	    add_2tup(hpp, szp, &res,
-		     am.mseg_alloc_carriers_size,
-		     bld_unstable_uint(hpp, szp, cs->curr.norm.mseg.size));
+	add_2tup(hpp, szp, &res,
+		 am.mseg_alloc_carriers_size,
+		 bld_unstable_uint(hpp, szp, cs->curr.norm.mseg.size));
 #endif
-	}
 	add_4tup(hpp, szp, &res,
 		 am.carriers_size,
 		 bld_unstable_uint(hpp, szp, curr_size),
 		 bld_unstable_uint(hpp, szp, cs->max.size),
 		 bld_unstable_uint(hpp, szp, cs->max_ever.size));
-	if (!small_block) {
-	    add_2tup(hpp, szp, &res,
-		     am.sys_alloc_carriers,
-		     bld_unstable_uint(hpp, szp, cs->curr.norm.sys_alloc.no));
+	add_2tup(hpp, szp, &res,
+		 am.sys_alloc_carriers,
+		 bld_unstable_uint(hpp, szp, cs->curr.norm.sys_alloc.no));
 #if HAVE_ERTS_MSEG
-	    add_2tup(hpp, szp, &res,
-		     am.mseg_alloc_carriers,
-		     bld_unstable_uint(hpp, szp, cs->curr.norm.mseg.no));
+	add_2tup(hpp, szp, &res,
+		 am.mseg_alloc_carriers,
+		 bld_unstable_uint(hpp, szp, cs->curr.norm.mseg.no));
 #endif
-	}
 	add_4tup(hpp, szp, &res,
 		 am.carriers,
 		 bld_unstable_uint(hpp, szp, curr_no),
@@ -2912,9 +2748,6 @@ info_calls(Allctr_t *allctr,
 	PRINT_CC_5(to, arg, prefix, "free",         allctr->calls.this_free);
 	PRINT_CC_5(to, arg, prefix, "realloc",      allctr->calls.this_realloc);
 
-	PRINT_CC_4(to, arg,         "sbmbc_alloc",  allctr->calls.sbmbc_alloc);
-	PRINT_CC_4(to, arg,         "sbmbc_free",   allctr->calls.sbmbc_free);
-
 #if HAVE_ERTS_MSEG
 	PRINT_CC_4(to, arg,         "mseg_alloc",   allctr->calls.mseg_alloc);
 	PRINT_CC_4(to, arg,         "mseg_dealloc", allctr->calls.mseg_dealloc);
@@ -2966,14 +2799,6 @@ info_calls(Allctr_t *allctr,
 		 bld_unstable_uint(hpp, szp, allctr->calls.mseg_alloc.no));
 #endif
 	add_3tup(hpp, szp, &res,
-		 am.sbmbc_free,
-		 bld_unstable_uint(hpp, szp, allctr->calls.sbmbc_free.giga_no),
-		 bld_unstable_uint(hpp, szp, allctr->calls.sbmbc_free.no));
-	add_3tup(hpp, szp, &res,
-		 am.sbmbc_alloc,
-		 bld_unstable_uint(hpp, szp, allctr->calls.sbmbc_alloc.giga_no),
-		 bld_unstable_uint(hpp, szp, allctr->calls.sbmbc_alloc.no));
-	add_3tup(hpp, szp, &res,
 		 allctr->name.realloc,
 		 bld_unstable_uint(hpp, szp, allctr->calls.this_realloc.giga_no),
 		 bld_unstable_uint(hpp, szp, allctr->calls.this_realloc.no));
@@ -3037,9 +2862,7 @@ info_options(Allctr_t *allctr,
 #endif
 		   "option lmbcs: %beu\n"
 		   "option smbcs: %beu\n"
-		   "option mbcgs: %beu\n"
-		   "option sbmbcs: %beu\n"
-		   "option sbmbct: %beu\n",
+		   "option mbcgs: %beu\n",
 		   topt,
 		   allctr->ramv ? "true" : "false",
 #if HALFWORD_HEAP
@@ -3059,9 +2882,7 @@ info_options(Allctr_t *allctr,
 #endif
 		   allctr->largest_mbc_size,
 		   allctr->smallest_mbc_size,
-		   allctr->mbc_growth_stages,
-		   allctr->sbmbc_size,
-		   allctr->sbmbc_threshold);
+		   allctr->mbc_growth_stages);
     }
 
     res = (*allctr->info_options)(allctr, "option ", print_to_p, print_to_arg,
@@ -3069,12 +2890,6 @@ info_options(Allctr_t *allctr,
 
     if (hpp || szp) {
 	add_2tup(hpp, szp, &res,
-		 am.sbmbct,
-		 bld_uint(hpp, szp, allctr->sbmbc_threshold));
-	add_2tup(hpp, szp, &res,
-		 am.sbmbcs,
-		 bld_uint(hpp, szp, allctr->sbmbc_size));
-	add_2tup(hpp, szp, &res,
 		 am.mbcgs,
 		 bld_uint(hpp, szp, allctr->mbc_growth_stages));
 	add_2tup(hpp, szp, &res,
@@ -3225,7 +3040,7 @@ erts_alcu_sz_info(Allctr_t *allctr,
 		  Uint **hpp,
 		  Uint *szp)
 {
-    Eterm res, sbmbcs, mbcs, sbcs, fix = THE_NON_VALUE;
+    Eterm res, mbcs, sbcs, fix = THE_NON_VALUE;
 
     res  = THE_NON_VALUE;
 
@@ -3254,14 +3069,11 @@ erts_alcu_sz_info(Allctr_t *allctr,
 	= allctr->sbcs.curr.norm.mseg.no + allctr->sbcs.curr.norm.sys_alloc.no;
     allctr->sbcs.blocks.max.no = allctr->sbcs.max.no;
 
-    update_max_ever_values(&allctr->sbmbcs);
     update_max_ever_values(&allctr->mbcs);
     update_max_ever_values(&allctr->sbcs);
 
     if (allctr->fix)
 	fix = sz_info_fix(allctr, print_to_p, print_to_arg, hpp, szp);
-    sbmbcs = sz_info_carriers(allctr, &allctr->sbmbcs, "sbmbcs ", print_to_p,
-			      print_to_arg, hpp, szp);
     mbcs = sz_info_carriers(allctr, &allctr->mbcs, "mbcs ", print_to_p,
 			    print_to_arg, hpp, szp);
     sbcs = sz_info_carriers(allctr, &allctr->sbcs, "sbcs ", print_to_p,
@@ -3271,13 +3083,11 @@ erts_alcu_sz_info(Allctr_t *allctr,
 	res = NIL;
 	add_2tup(hpp, szp, &res, am.sbcs, sbcs);
 	add_2tup(hpp, szp, &res, am.mbcs, mbcs);
-	add_2tup(hpp, szp, &res, am.sbmbcs, sbmbcs);
 	if (allctr->fix)
 	    add_2tup(hpp, szp, &res, am.fix_types, fix);
     }
 
     if (begin_max_period) {
-	reset_max_values(&allctr->sbmbcs);
 	reset_max_values(&allctr->mbcs);
 	reset_max_values(&allctr->sbcs);
     }
@@ -3302,7 +3112,7 @@ erts_alcu_info(Allctr_t *allctr,
 	       Uint **hpp,
 	       Uint *szp)
 {
-    Eterm res, sett, sbmbcs, mbcs, sbcs, calls, fix = THE_NON_VALUE;
+    Eterm res, sett, mbcs, sbcs, calls, fix = THE_NON_VALUE;
 
     res  = THE_NON_VALUE;
 
@@ -3331,7 +3141,6 @@ erts_alcu_info(Allctr_t *allctr,
 	= allctr->sbcs.curr.norm.mseg.no + allctr->sbcs.curr.norm.sys_alloc.no;
     allctr->sbcs.blocks.max.no = allctr->sbcs.max.no;
 
-    update_max_ever_values(&allctr->sbmbcs);
     update_max_ever_values(&allctr->mbcs);
     update_max_ever_values(&allctr->sbcs);
 
@@ -3346,8 +3155,6 @@ erts_alcu_info(Allctr_t *allctr,
     sett = info_options(allctr, print_to_p, print_to_arg, hpp, szp);
     if (allctr->fix)
 	fix = sz_info_fix(allctr, print_to_p, print_to_arg, hpp, szp);
-    sbmbcs = info_carriers(allctr, &allctr->sbmbcs, "sbmbcs ", print_to_p,
-			   print_to_arg, hpp, szp);
     mbcs = info_carriers(allctr, &allctr->mbcs, "mbcs ", print_to_p,
 			 print_to_arg, hpp, szp);
     sbcs = info_carriers(allctr, &allctr->sbcs, "sbcs ", print_to_p,
@@ -3360,7 +3167,6 @@ erts_alcu_info(Allctr_t *allctr,
 	add_2tup(hpp, szp, &res, am.calls, calls);
 	add_2tup(hpp, szp, &res, am.sbcs, sbcs);
 	add_2tup(hpp, szp, &res, am.mbcs, mbcs);
-	add_2tup(hpp, szp, &res, am.sbmbcs, sbmbcs);
 	if (allctr->fix)
 	    add_2tup(hpp, szp, &res, am.fix_types, fix);
 	add_2tup(hpp, szp, &res, am.options, sett);
@@ -3371,7 +3177,6 @@ erts_alcu_info(Allctr_t *allctr,
     }
 
     if (begin_max_period) {
-	reset_max_values(&allctr->sbmbcs);
 	reset_max_values(&allctr->mbcs);
 	reset_max_values(&allctr->sbcs);
     }
@@ -3399,12 +3204,10 @@ erts_alcu_current_size(Allctr_t *allctr, AllctrSize_t *size, ErtsAlcUFixInfo_t *
 
     size->carriers = allctr->mbcs.curr.norm.mseg.size;
     size->carriers += allctr->mbcs.curr.norm.sys_alloc.size;
-    size->carriers += allctr->sbmbcs.curr.small_block.size;
     size->carriers += allctr->sbcs.curr.norm.mseg.size;
     size->carriers += allctr->sbcs.curr.norm.sys_alloc.size;
 
     size->blocks = allctr->mbcs.blocks.curr.size;
-    size->blocks += allctr->sbmbcs.blocks.curr.size;
     size->blocks += allctr->sbcs.blocks.curr.size;
 
     if (fi) {
@@ -3762,29 +3565,6 @@ do_erts_alcu_realloc(ErtsAlcType_t type,
     
     blk = UMEM2BLK(p);
 
-    if (allctr->sbmbc_threshold > 0) {
-	Uint old_sz, new_sz, lim;
-	lim = allctr->sbmbc_threshold;
-	old_sz = BLK_SZ(blk);
-	new_sz = UMEMSZ2BLKSZ(allctr, size);
-	if ((old_sz < lim && lim <= new_sz)
-	    || (new_sz < lim && lim <= old_sz)) {
-	    /* *Need* to move it... */
-
-	    INC_CC(allctr->calls.this_realloc);
-	    res = do_erts_alcu_alloc(type, extra, size);
-	    DEC_CC(allctr->calls.this_alloc);
-
-	    sys_memcpy(res, p, MIN(size, old_sz - ABLK_HDR_SZ));
-
-	    do_erts_alcu_free(type, extra, p);
-	    DEC_CC(allctr->calls.this_free);
-	    return res;
-	}
-	if (old_sz < lim)
-	    alcu_flgs |= ERTS_ALCU_FLG_SBMBC;
-    }
-
     if (size < allctr->sbc_threshold) {
 	if (IS_MBC_BLK(blk))
 	    res = mbc_realloc(allctr, p, size, alcu_flgs);
@@ -4190,27 +3970,6 @@ erts_alcu_start(Allctr_t *allctr, AllctrInit_t *init)
     }
 #endif
 
-
-
-    allctr->sbmbc_threshold		= init->sbmbct;
-
-    if (!erts_have_sbmbc_alloc
-	|| ERTS_IS_SBMBC_ALLOCATOR_NO__(allctr->alloc_no))
-	allctr->sbmbc_threshold = 0;
-
-    if (!allctr->sbmbc_threshold)
-	allctr->sbmbc_size = 0;
-    else {
-	Uint min_size;
-	allctr->sbmbc_size = init->sbmbcs;
-	min_size = allctr->sbmbc_threshold;
-	min_size += allctr->min_block_size;
-	min_size += MBC_HEADER_SIZE(allctr);
-	if (allctr->sbmbc_size < min_size)
-	    allctr->sbmbc_size = min_size;
-    }
-
-
 #if HAVE_ERTS_MSEG
     if (allctr->mseg_opt.abs_shrink_th > ~((UWord) 0) / 100)
 	allctr->mseg_opt.abs_shrink_th = ~((UWord) 0) / 100;
@@ -4222,16 +3981,12 @@ erts_alcu_start(Allctr_t *allctr, AllctrInit_t *init)
 	
 #ifdef ERTS_ENABLE_LOCK_COUNT
 	erts_mtx_init_x_opt(&allctr->mutex,
-			    ERTS_IS_SBMBC_ALLOCATOR_NO__(allctr->alloc_no)
-			    ? "sbmbc_alloc"
-			    : "alcu_allocator",
+			    "alcu_allocator",
 			    make_small(allctr->alloc_no),
 			    ERTS_LCNT_LT_ALLOC);
 #else
 	erts_mtx_init_x(&allctr->mutex,
-			ERTS_IS_SBMBC_ALLOCATOR_NO__(allctr->alloc_no)
-			? "sbmbc_alloc"
-			: "alcu_allocator",
+			"alcu_allocator",
 			make_small(allctr->alloc_no));
 #endif /*ERTS_ENABLE_LOCK_COUNT*/
 	
@@ -4326,8 +4081,6 @@ erts_alcu_stop(Allctr_t *allctr)
 	destroy_carrier(allctr, SBC2BLK(allctr, allctr->sbc_list.first));
     while (allctr->mbc_list.first)
 	destroy_carrier(allctr, MBC_TO_FIRST_BLK(allctr, allctr->mbc_list.first));
-    while (allctr->sbmbc_list.first)
-	destroy_sbmbc(allctr, MBC_TO_FIRST_BLK(allctr, allctr->sbmbc_list.first));
 
 #ifdef USE_THREADS
     if (allctr->thread_safe)
@@ -4423,12 +4176,10 @@ erts_alcu_verify_unused(Allctr_t *allctr)
     no = allctr->sbcs.curr.norm.mseg.no;
     no += allctr->sbcs.curr.norm.sys_alloc.no;
     no += allctr->mbcs.blocks.curr.no;
-    no += allctr->sbmbcs.blocks.curr.no;
 
     if (no) {
 	UWord sz = allctr->sbcs.blocks.curr.size;
 	sz += allctr->mbcs.blocks.curr.size;
-	sz += allctr->sbmbcs.blocks.curr.size;
 	erl_exit(ERTS_ABORT_EXIT,
 		 "%salloc() used when expected to be unused!\n"
 		 "Total amount of blocks allocated: %bpu\n"
@@ -4562,7 +4313,7 @@ check_blk_carrier(Allctr_t *allctr, Block_t *iblk)
 	cl = &allctr->mbc_list;
     }
 
-#if 0 /* FIXIT sbmbc */
+#ifdef DEBUG
     if (cl->first == crr) {
 	ASSERT(!crr->prev);
     }
diff --git a/erts/emulator/beam/erl_alloc_util.h b/erts/emulator/beam/erl_alloc_util.h
index 739871957c..75f6de9936 100644
--- a/erts/emulator/beam/erl_alloc_util.h
+++ b/erts/emulator/beam/erl_alloc_util.h
@@ -55,8 +55,6 @@ typedef struct {
     UWord lmbcs;
     UWord smbcs;
     UWord mbcgs;
-    UWord sbmbct;
-    UWord sbmbcs;
 
     void *fix;
     size_t *fix_type_size;
@@ -100,8 +98,6 @@ typedef struct {
     10*1024*1024,	/* (bytes)  lmbcs:  largest mbc size             */\
     1024*1024,		/* (bytes)  smbcs:  smallest mbc size            */\
     10,			/* (amount) mbcgs:  mbc growth stages            */\
-    256,	       	/* (bytes)  sbmbct:  small block mbc threshold   */\
-    8*1024,		/* (bytes)  sbmbcs:  small block mbc size        */ \
     /* --- Data not options -------------------------------------------- */\
     NULL,		/* (ptr)    fix                                  */\
     NULL		/* (ptr)    fix_type_size                        */\
@@ -134,8 +130,6 @@ typedef struct {
     1024*1024,		/* (bytes)  lmbcs:  largest mbc size             */\
     128*1024,		/* (bytes)  smbcs:  smallest mbc size            */\
     10,			/* (amount) mbcgs:  mbc growth stages            */\
-    256,	       	/* (bytes)  sbmbct:  small block mbc threshold   */\
-    8*1024,		/* (bytes)  sbmbcs:  small block mbc size        */ \
     /* --- Data not options -------------------------------------------- */\
     NULL,		/* (ptr)    fix                                  */\
     NULL		/* (ptr)    fix_type_size                        */\
@@ -181,7 +175,6 @@ erts_aint32_t erts_alcu_fix_alloc_shrink(Allctr_t *, erts_aint32_t);
 #define ERL_ALLOC_UTIL_IMPL__
 
 #define ERTS_ALCU_FLG_FAIL_REALLOC_MOVE		(((Uint32) 1) << 0)
-#define ERTS_ALCU_FLG_SBMBC			(((Uint32) 1) << 1)
 
 #ifdef USE_THREADS
 #define ERL_THREADS_EMU_INTERNAL__
@@ -245,10 +238,8 @@ erts_aint32_t erts_alcu_fix_alloc_shrink(Allctr_t *, erts_aint32_t);
 #  define MBC_ABLK_OFFSET_SHIFT  (sizeof(UWord)*8 - MBC_ABLK_OFFSET_BITS)
 #  define MBC_ABLK_OFFSET_MASK   (~((UWord)0) << MBC_ABLK_OFFSET_SHIFT)
 #  define MBC_ABLK_SZ_MASK	(~MBC_ABLK_OFFSET_MASK & ~FLG_MASK)
-#  define HAVE_ERTS_SBMBC 0
 #else
 #  define MBC_ABLK_SZ_MASK	(~FLG_MASK)
-#  define HAVE_ERTS_SBMBC 1
 #endif
 
 #define MBC_ABLK_SZ(B) (ASSERT_EXPR(!is_sbc_blk(B)), (B)->bhdr & MBC_ABLK_SZ_MASK)
@@ -258,8 +249,6 @@ erts_aint32_t erts_alcu_fix_alloc_shrink(Allctr_t *, erts_aint32_t);
 #define CARRIER_SZ(C) \
   ((C)->chdr & CARRIER_SZ_MASK)
 
-extern int erts_have_sbmbc_alloc;
-
 typedef union {char c[ERTS_ALLOC_ALIGN_BYTES]; long l; double d;} Unit_t;
 
 typedef struct Carrier_t_ Carrier_t;
@@ -332,7 +321,6 @@ typedef struct {
 	    StatValues_t	mseg;
 	    StatValues_t	sys_alloc;
 	} norm;
-	StatValues_t	small_block;
     } curr;
     StatValues_t	max;
     StatValues_t	max_ever;
@@ -443,8 +431,6 @@ struct Allctr_t_ {
     Uint		largest_mbc_size;
     Uint		smallest_mbc_size;
     Uint		mbc_growth_stages;
-    Uint		sbmbc_threshold;
-    Uint		sbmbc_size;
 
 #if HAVE_ERTS_MSEG
     ErtsMsegOpt_t	mseg_opt;
@@ -457,7 +443,6 @@ struct Allctr_t_ {
     Uint		min_block_size;
 
     /* Carriers */
-    CarrierList_t	sbmbc_list;
     CarrierList_t	mbc_list;
     CarrierList_t	sbc_list;
 
@@ -512,8 +497,6 @@ struct Allctr_t_ {
 	CallCounter_t	this_alloc;
 	CallCounter_t	this_free;
 	CallCounter_t	this_realloc;
-	CallCounter_t	sbmbc_alloc;
-	CallCounter_t	sbmbc_free;
 	CallCounter_t	mseg_alloc;
 	CallCounter_t	mseg_dealloc;
 	CallCounter_t	mseg_realloc;
@@ -524,8 +507,7 @@ struct Allctr_t_ {
 
     CarriersStats_t	sbcs;
     CarriersStats_t	mbcs;
-    CarriersStats_t	sbmbcs;
-
+    
 #ifdef DEBUG
 #ifdef USE_THREADS
     struct {
diff --git a/erts/emulator/beam/erl_ao_firstfit_alloc.c b/erts/emulator/beam/erl_ao_firstfit_alloc.c
index 98dd98bb14..dd4a2e3b5b 100644
--- a/erts/emulator/beam/erl_ao_firstfit_alloc.c
+++ b/erts/emulator/beam/erl_ao_firstfit_alloc.c
@@ -466,8 +466,7 @@ aoff_unlink_free_block(Allctr_t *allctr, Block_t *del, Uint32 flags)
     AOFF_Carrier_t *crr = (AOFF_Carrier_t*) FBLK_TO_MBC(del);
 
     ASSERT(crr->rbt_node.hdr.bhdr == crr->root->max_sz);
-    HARD_CHECK_IS_MEMBER(((flags & ERTS_ALCU_FLG_SBMBC) ? alc->sbmbc_root : alc->mbc_root),
-			 &crr->rbt_node);
+    HARD_CHECK_IS_MEMBER(alc->mbc_root, &crr->rbt_node);
     HARD_CHECK_TREE(&crr->crr, alc->bf_within_carrier, crr->root, 0);
 
     rbt_delete(&crr->root, (AOFF_RBTree_t*)del);
@@ -667,8 +666,7 @@ aoff_link_free_block(Allctr_t *allctr, Block_t *block, Uint32 flags)
 
     ASSERT(allctr == blk_crr->crr.allctr);
     ASSERT(blk_crr->rbt_node.hdr.bhdr == (blk_crr->root ? blk_crr->root->max_sz : 0));
-    HARD_CHECK_IS_MEMBER(((flags & ERTS_ALCU_FLG_SBMBC) ? alc->sbmbc_root : alc->mbc_root),
-			 &blk_crr->rbt_node);
+    HARD_CHECK_IS_MEMBER(alc->mbc_root, &blk_crr->rbt_node);
     HARD_CHECK_TREE(&blk_crr->crr, alc->bf_within_carrier, blk_crr->root, 0);
 
     rbt_insert(alc->bf_within_carrier, &blk_crr->root, blk);
@@ -763,8 +761,7 @@ aoff_get_free_block(Allctr_t *allctr, Uint size,
 		    Block_t *cand_blk, Uint cand_size, Uint32 flags)
 {
     AOFFAllctr_t *alc = (AOFFAllctr_t *) allctr;
-    AOFF_RBTree_t *crr_node = ((flags & ERTS_ALCU_FLG_SBMBC)
-			       ? alc->sbmbc_root : alc->mbc_root);
+    AOFF_RBTree_t *crr_node = alc->mbc_root;
     AOFF_Carrier_t* crr;
     AOFF_RBTree_t *blk = NULL;
 #ifdef HARD_DEBUG
@@ -809,8 +806,7 @@ static void aoff_creating_mbc(Allctr_t *allctr, Carrier_t *carrier, Uint32 flags
 {
     AOFFAllctr_t *alc = (AOFFAllctr_t *) allctr;
     AOFF_Carrier_t *crr = (AOFF_Carrier_t*) carrier;
-    AOFF_RBTree_t **root = ((flags & ERTS_ALCU_FLG_SBMBC)
-			    ? &alc->sbmbc_root : &alc->mbc_root);
+    AOFF_RBTree_t **root = &alc->mbc_root;
 
     HARD_CHECK_TREE(NULL, 0, *root, 0);
 
@@ -829,8 +825,7 @@ static void aoff_destroying_mbc(Allctr_t *allctr, Carrier_t *carrier, Uint32 fla
 {
     AOFFAllctr_t *alc = (AOFFAllctr_t *) allctr;
     AOFF_Carrier_t *crr = (AOFF_Carrier_t*) carrier;
-    AOFF_RBTree_t *root = ((flags & ERTS_ALCU_FLG_SBMBC)
-			    ? alc->sbmbc_root : alc->mbc_root);
+    AOFF_RBTree_t *root = alc->mbc_root;
 
     if (crr->rbt_node.parent || &crr->rbt_node == root) {
 	aoff_remove_mbc(allctr, carrier, flags);
@@ -842,8 +837,7 @@ static void aoff_add_mbc(Allctr_t *allctr, Carrier_t *carrier, Uint32 flags)
 {
     AOFFAllctr_t *alc = (AOFFAllctr_t *) allctr;
     AOFF_Carrier_t *crr = (AOFF_Carrier_t*) carrier;
-    AOFF_RBTree_t **root = ((flags & ERTS_ALCU_FLG_SBMBC)
-			    ? &alc->sbmbc_root : &alc->mbc_root);
+    AOFF_RBTree_t **root = &alc->mbc_root;
 
     HARD_CHECK_TREE(NULL, 0, *root, 0);
 
@@ -858,8 +852,7 @@ static void aoff_remove_mbc(Allctr_t *allctr, Carrier_t *carrier, Uint32 flags)
 {
     AOFFAllctr_t *alc = (AOFFAllctr_t *) allctr;
     AOFF_Carrier_t *crr = (AOFF_Carrier_t*) carrier;
-    AOFF_RBTree_t **root = ((flags & ERTS_ALCU_FLG_SBMBC)
-			    ? &alc->sbmbc_root : &alc->mbc_root);
+    AOFF_RBTree_t **root = &alc->mbc_root;
 
     ASSERT(allctr == carrier->allctr);
     HARD_CHECK_TREE(NULL, 0, *root, 0);
diff --git a/erts/emulator/beam/erl_ao_firstfit_alloc.h b/erts/emulator/beam/erl_ao_firstfit_alloc.h
index 36995a20f0..87427e8e62 100644
--- a/erts/emulator/beam/erl_ao_firstfit_alloc.h
+++ b/erts/emulator/beam/erl_ao_firstfit_alloc.h
@@ -52,7 +52,6 @@ struct AOFFAllctr_t_ {
     Allctr_t		allctr; /* Has to be first! */
 
     struct AOFF_RBTree_t_* mbc_root;
-    struct AOFF_RBTree_t_* sbmbc_root;
     int bf_within_carrier;
 };
 
diff --git a/erts/emulator/beam/erl_bestfit_alloc.c b/erts/emulator/beam/erl_bestfit_alloc.c
index dff69faa4e..dda87f9e53 100644
--- a/erts/emulator/beam/erl_bestfit_alloc.c
+++ b/erts/emulator/beam/erl_bestfit_alloc.c
@@ -415,9 +415,7 @@ tree_delete(Allctr_t *allctr, Block_t *del, Uint32 flags)
 {
     BFAllctr_t *bfallctr = (BFAllctr_t *) allctr;
     Uint spliced_is_black;
-    RBTree_t **root = ((flags & ERTS_ALCU_FLG_SBMBC)
-		       ? &bfallctr->sbmbc_root
-		       : &bfallctr->mbc_root);
+    RBTree_t **root = &bfallctr->mbc_root;
     RBTree_t *x, *y, *z = (RBTree_t *) del;
     RBTree_t null_x; /* null_x is used to get the fixup started when we
 			splice out a node without children. */
@@ -593,9 +591,7 @@ static void
 aobf_link_free_block(Allctr_t *allctr, Block_t *block, Uint32 flags)
 {
     BFAllctr_t *bfallctr = (BFAllctr_t *) allctr;
-    RBTree_t **root = ((flags & ERTS_ALCU_FLG_SBMBC)
-		       ? &bfallctr->sbmbc_root
-		       : &bfallctr->mbc_root);
+    RBTree_t **root = &bfallctr->mbc_root;
     RBTree_t *blk = (RBTree_t *) block;
     Uint blk_sz = BF_BLK_SZ(blk);
 
@@ -663,9 +659,7 @@ aobf_get_free_block(Allctr_t *allctr, Uint size,
 		    Uint32 flags)
 {
     BFAllctr_t *bfallctr = (BFAllctr_t *) allctr;
-    RBTree_t **root = ((flags & ERTS_ALCU_FLG_SBMBC)
-		       ? &bfallctr->sbmbc_root
-		       : &bfallctr->mbc_root);
+    RBTree_t **root = &bfallctr->mbc_root;
     RBTree_t *x = *root;
     RBTree_t *blk = NULL;
     Uint blk_sz;
@@ -712,9 +706,7 @@ static void
 bf_link_free_block(Allctr_t *allctr, Block_t *block, Uint32 flags)
 {
     BFAllctr_t *bfallctr = (BFAllctr_t *) allctr;
-    RBTree_t **root = ((flags & ERTS_ALCU_FLG_SBMBC)
-		       ? &bfallctr->sbmbc_root
-		       : &bfallctr->mbc_root);
+    RBTree_t **root = &bfallctr->mbc_root;
     RBTree_t *blk = (RBTree_t *) block;
     Uint blk_sz = BF_BLK_SZ(blk);
 
@@ -786,9 +778,7 @@ static ERTS_INLINE void
 bf_unlink_free_block(Allctr_t *allctr, Block_t *block, Uint32 flags)
 {
     BFAllctr_t *bfallctr = (BFAllctr_t *) allctr;
-    RBTree_t **root = ((flags & ERTS_ALCU_FLG_SBMBC)
-		       ? &bfallctr->sbmbc_root
-		       : &bfallctr->mbc_root);
+    RBTree_t **root = &bfallctr->mbc_root;
     RBTree_t *x = (RBTree_t *) block;
 
     if (IS_LIST_ELEM(x)) {
@@ -829,9 +819,7 @@ bf_get_free_block(Allctr_t *allctr, Uint size,
 		  Uint32 flags)
 {
     BFAllctr_t *bfallctr = (BFAllctr_t *) allctr;
-    RBTree_t **root = ((flags & ERTS_ALCU_FLG_SBMBC)
-		       ? &bfallctr->sbmbc_root
-		       : &bfallctr->mbc_root);
+    RBTree_t **root = &bfallctr->mbc_root;
     RBTree_t *x = *root;
     RBTree_t *blk = NULL;
     Uint blk_sz;
diff --git a/erts/emulator/beam/erl_bestfit_alloc.h b/erts/emulator/beam/erl_bestfit_alloc.h
index f2d2f07d7a..be8b2b871d 100644
--- a/erts/emulator/beam/erl_bestfit_alloc.h
+++ b/erts/emulator/beam/erl_bestfit_alloc.h
@@ -55,7 +55,6 @@ struct BFAllctr_t_ {
     Allctr_t		allctr; /* Has to be first! */
 
     RBTree_t *		mbc_root;
-    RBTree_t *		sbmbc_root;
     int 		address_order;
 };
 
diff --git a/erts/emulator/beam/erl_goodfit_alloc.c b/erts/emulator/beam/erl_goodfit_alloc.c
index 72620a362b..bd728b8a90 100644
--- a/erts/emulator/beam/erl_goodfit_alloc.c
+++ b/erts/emulator/beam/erl_goodfit_alloc.c
@@ -203,8 +203,6 @@ erts_gfalc_start(GFAllctr_t *gfallctr,
 
     sys_memcpy((void *) gfallctr, (void *) &zero.allctr, sizeof(GFAllctr_t));
 
-    init->sbmbct = 0; /* Small mbc not yet supported by goodfit */
-
     allctr->mbc_header_size		= sizeof(Carrier_t);
     allctr->min_mbc_size		= MIN_MBC_SZ;
     allctr->min_mbc_first_free_size	= MIN_MBC_FIRST_FREE_SZ;
diff --git a/erts/emulator/beam/erl_instrument.c b/erts/emulator/beam/erl_instrument.c
index 1aea3f65bc..df7c443387 100644
--- a/erts/emulator/beam/erl_instrument.c
+++ b/erts/emulator/beam/erl_instrument.c
@@ -1236,8 +1236,6 @@ erts_instr_init(int stat, int map_stat)
     sys_memzero((void *) stats->n, sizeof(Stat_t)*(ERTS_ALC_N_MAX+1));
 
     for (i = ERTS_ALC_A_MIN; i <= ERTS_ALC_A_MAX; i++) {
-	if (ERTS_IS_SBMBC_ALLOCATOR_NO__(i))
-	    continue;
 	if (erts_allctrs_info[i].enabled)
 	    stats->ap[i] = &stats->a[i];
 	else
@@ -1251,8 +1249,6 @@ erts_instr_init(int stat, int map_stat)
 	erts_instr_memory_map = 1;
 	erts_instr_stat = 1;
 	for (i = ERTS_ALC_A_MIN; i <= ERTS_ALC_A_MAX; i++) {
-	    if (ERTS_IS_SBMBC_ALLOCATOR_NO__(i))
-		continue;
 	    erts_allctrs[i].alloc	= map_stat_alloc;
 	    erts_allctrs[i].realloc	= map_stat_realloc;
 	    erts_allctrs[i].free	= map_stat_free;
@@ -1265,8 +1261,6 @@ erts_instr_init(int stat, int map_stat)
     else {
 	erts_instr_stat = 1;
 	for (i = ERTS_ALC_A_MIN; i <= ERTS_ALC_A_MAX; i++) {
-	    if (ERTS_IS_SBMBC_ALLOCATOR_NO__(i))
-		continue;
 	    erts_allctrs[i].alloc	= stat_alloc;
 	    erts_allctrs[i].realloc	= stat_realloc;
 	    erts_allctrs[i].free	= stat_free;
diff --git a/erts/emulator/beam/erl_lock_check.c b/erts/emulator/beam/erl_lock_check.c
index a1d270adba..bc59fe55d4 100644
--- a/erts/emulator/beam/erl_lock_check.c
+++ b/erts/emulator/beam/erl_lock_check.c
@@ -150,7 +150,6 @@ static erts_lc_lock_order_t erts_lock_order[] = {
     {	"instr_x",				NULL			},
     {	"instr",				NULL			},
     {	"alcu_allocator",			"index"			},
-    {	"sbmbc_alloc",				"index"			},
     {	"mseg",					NULL			},
 #if HALFWORD_HEAP
     {	"pmmap",				NULL			},
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, _, _}}
diff --git a/erts/etc/common/erlexec.c b/erts/etc/common/erlexec.c
index 31d9b2e0ad..aaaeb0eaa8 100644
--- a/erts/etc/common/erlexec.c
+++ b/erts/etc/common/erlexec.c
@@ -64,7 +64,6 @@
 static const char plusM_au_allocs[]= {
     'u',	/* all alloc_util allocators */
     'B',	/* binary_alloc		*/
-    'C',	/* sbmbc_alloc		*/
     'D',	/* std_alloc		*/
     'E',	/* ets_alloc		*/
     'F',	/* fix_alloc		*/
@@ -95,8 +94,6 @@ static char *plusM_au_alloc_switches[] = {
     "rsbcst",
     "sbct",
     "smbcs",
-    "sbmbcs",
-    "sbmbct",
     NULL
 };
 
diff --git a/erts/preloaded/ebin/erlang.beam b/erts/preloaded/ebin/erlang.beam
index 315f9ebd47..a792d667c8 100644
--- a/erts/preloaded/ebin/erlang.beam
+++ b/erts/preloaded/ebin/erlang.beam
diff --git a/erts/preloaded/src/erlang.erl b/erts/preloaded/src/erlang.erl
index 6929ca3fa5..3186ce6e4c 100644
--- a/erts/preloaded/src/erlang.erl
+++ b/erts/preloaded/src/erlang.erl
@@ -3114,8 +3114,8 @@ max(A, _) -> A.
                      | 'atom' | 'atom_used' | 'binary' | 'code' | 'ets'
                      | 'low' | 'maximum'.
 
--define(CARRIER_ALLOCS, [mseg_alloc, sbmbc_alloc, sbmbc_low_alloc]).
--define(LOW_ALLOCS, [sbmbc_low_alloc, ll_low_alloc, std_low_alloc]).
+-define(CARRIER_ALLOCS, [mseg_alloc]).
+-define(LOW_ALLOCS, [ll_low_alloc, std_low_alloc]).
 -define(ALL_NEEDED_ALLOCS, (erlang:system_info(alloc_util_allocators)
 			    -- ?CARRIER_ALLOCS)).
 
@@ -3286,8 +3286,7 @@ get_blocks_size([], Acc) ->
     Acc.
 
 blocks_size([{Carriers, SizeList} | Rest], Acc) when Carriers == mbcs;
-						     Carriers == sbcs;
-						     Carriers == sbmbcs ->
+						     Carriers == sbcs ->
     blocks_size(Rest, get_blocks_size(SizeList, Acc));
 blocks_size([_ | Rest], Acc) ->
     blocks_size(Rest, Acc);