Merge tag 'OTP-19.0' into sverker/19/binary_to_atom-utf8-crash/ERL-474/OTP-14590

24 files changed, 828 insertions, 343 deletions

diff --git a/erts/emulator/test/alloc_SUITE_data/Makefile.src b/erts/emulator/test/alloc_SUITE_data/Makefile.src
index 1d4286e671..e31de54e1b 100644
--- a/erts/emulator/test/alloc_SUITE_data/Makefile.src
+++ b/erts/emulator/test/alloc_SUITE_data/Makefile.src
@@ -1,13 +1,14 @@
-# ``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 via the world wide web 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.
+# ``Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#     http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
 # 
 # The Initial Developer of the Original Code is Ericsson Utvecklings AB.
 # Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
@@ -24,7 +25,8 @@ TEST_DRVS =	basic@dll@		\
 		bucket_mask@dll@	\
 		rbtree@dll@		\
 		mseg_clear_cache@dll@	\
-		cpool@dll@
+		cpool@dll@		\
+		migration@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 c37b074f93..97ee58cdad 100644
--- a/erts/emulator/test/alloc_SUITE_data/allocator_test.h
+++ b/erts/emulator/test/alloc_SUITE_data/allocator_test.h
@@ -1,13 +1,14 @@
-/* ``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 via the world wide web 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.
+/* ``Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  * 
  * The Initial Developer of the Original Code is Ericsson Utvecklings AB.
  * Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
@@ -19,9 +20,20 @@
 #ifndef ALLOCATOR_TEST_H__
 #define ALLOCATOR_TEST_H__
 
-typedef ErlDrvUInt Ulong;
+#if SIZEOF_VOID_P == SIZEOF_INT
+typedef unsigned int Ulong;
+#elif SIZEOF_VOID_P == SIZEOF_LONG
+typedef unsigned long Ulong;
+#elif SIZEOF_VOID_P == SIZEOF_LONG_LONG
+typedef unsigned long long Ulong;
+#else
+# error No pointer sized integer type found ???
+#endif
 
-#ifndef __WIN32__
+#ifdef __WIN32__
+typedef Ulong erts_alc_test_Fn(Ulong, Ulong, Ulong, Ulong);
+#  define erts_alc_test ((erts_alc_test_Fn*)WinDynNifCallbacks.erts_alc_test)
+#else
 Ulong erts_alc_test(Ulong, Ulong, Ulong, Ulong);
 #endif
 
@@ -84,6 +96,7 @@ typedef void* erts_cond;
 #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)))
+#define UMEM2BLK_TEST(P)	((Block_t*)	ALC_TEST1(0x025, (P)))
 
 /* From erl_goodfit_alloc.c */
 #define BKT_IX(A, S)		((Ulong)	ALC_TEST2(0x100, (A), (S)))
@@ -102,7 +115,8 @@ typedef void* erts_cond;
 #define RBT_IS_TREE(T)		((Ulong)	ALC_TEST1(RBT_OP(7), (T)))
 #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)))
+#define IS_BF(A)		((Ulong)	ALC_TEST1(RBT_OP(0xa), (A)))
+#define RBT_PREV(T)		((RBTL_t *)	ALC_TEST1(RBT_OP(0xb), (T)))
 
 /* From erl_mseg.c */
 #define HAVE_MSEG()		((int)		ALC_TEST0(0x400))
@@ -140,5 +154,9 @@ typedef void* erts_cond;
 #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))
+#define ALLOC_TEST(S)		((void*)	ALC_TEST1(0xf14, (S)))
+#define FREE_TEST(P)		((void)		ALC_TEST1(0xf15, (P)))
+#define SET_TEST_MBC_USER_HEADER(SZ,CMBC,DMBC) ((int)ALC_TEST3(0xf16, (SZ), (CMBC), (DMBC)))
+#define GET_TEST_MBC_SIZE()     ((int)          ALC_TEST0(0xf17))
 
 #endif
diff --git a/erts/emulator/test/alloc_SUITE_data/basic.c b/erts/emulator/test/alloc_SUITE_data/basic.c
index 0c27665712..debb3d7ebe 100644
--- a/erts/emulator/test/alloc_SUITE_data/basic.c
+++ b/erts/emulator/test/alloc_SUITE_data/basic.c
@@ -1,13 +1,14 @@
-/* ``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 via the world wide web 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.
+/* ``Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  * 
  * The Initial Developer of the Original Code is Ericsson Utvecklings AB.
  * Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
@@ -59,3 +60,6 @@ testcase_cleanup(TestCaseState_t *tcs)
     if (tcs->extra)
 	STOP_ALC((Allctr_t *) tcs->extra);
 }
+
+ERL_NIF_INIT(basic, testcase_nif_funcs, testcase_nif_init,
+	     NULL, NULL, NULL);
diff --git a/erts/emulator/test/alloc_SUITE_data/basic.erl b/erts/emulator/test/alloc_SUITE_data/basic.erl
new file mode 100644
index 0000000000..a018fd5582
--- /dev/null
+++ b/erts/emulator/test/alloc_SUITE_data/basic.erl
@@ -0,0 +1,10 @@
+-module(basic).
+
+-export([init/1, start/1, run/1, stop/1]).
+
+init(File) ->
+    ok = erlang:load_nif(File, 0).
+
+start(_) -> erlang:nif_error(not_loaded).
+run(_)  -> erlang:nif_error(not_loaded).
+stop(_) -> erlang:nif_error(not_loaded).
diff --git a/erts/emulator/test/alloc_SUITE_data/bucket_index.c b/erts/emulator/test/alloc_SUITE_data/bucket_index.c
index 32fd16fc10..45cb53fbf7 100644
--- a/erts/emulator/test/alloc_SUITE_data/bucket_index.c
+++ b/erts/emulator/test/alloc_SUITE_data/bucket_index.c
@@ -1,13 +1,14 @@
-/* ``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 via the world wide web 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.
+/* ``Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  * 
  * The Initial Developer of the Original Code is Ericsson Utvecklings AB.
  * Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
@@ -112,3 +113,5 @@ test_it(TestCaseState_t *tcs, unsigned sbct)
 		    sbct ? sbct_buf : "default");
 }
 
+ERL_NIF_INIT(bucket_index, testcase_nif_funcs, testcase_nif_init,
+	     NULL, NULL, NULL);
diff --git a/erts/emulator/test/alloc_SUITE_data/bucket_index.erl b/erts/emulator/test/alloc_SUITE_data/bucket_index.erl
new file mode 100644
index 0000000000..c54f54e2f5
--- /dev/null
+++ b/erts/emulator/test/alloc_SUITE_data/bucket_index.erl
@@ -0,0 +1,10 @@
+-module(bucket_index).
+
+-export([init/1, start/1, run/1, stop/1]).
+
+init(File) ->
+    ok = erlang:load_nif(File, 0).
+
+start(_) -> erlang:nif_error(not_loaded).
+run(_)  -> erlang:nif_error(not_loaded).
+stop(_) -> erlang:nif_error(not_loaded).
diff --git a/erts/emulator/test/alloc_SUITE_data/bucket_mask.c b/erts/emulator/test/alloc_SUITE_data/bucket_mask.c
index 34979cacf1..c94c265f4e 100644
--- a/erts/emulator/test/alloc_SUITE_data/bucket_mask.c
+++ b/erts/emulator/test/alloc_SUITE_data/bucket_mask.c
@@ -1,13 +1,14 @@
-/* ``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 via the world wide web 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.
+/* ``Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  * 
  * The Initial Developer of the Original Code is Ericsson Utvecklings AB.
  * Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
@@ -51,7 +52,7 @@ testcase_run(TestCaseState_t *tcs)
     typedef struct linked_block {
 	struct linked_block* next;
     }Linked;
-    Linked* link;
+    Linked* link = NULL;
     Linked* fence_list;
     Linked* pad_list;
     void* tmp;
@@ -182,3 +183,5 @@ testcase_run(TestCaseState_t *tcs)
     tcs->extra = NULL;
 }
 
+ERL_NIF_INIT(bucket_mask, testcase_nif_funcs, testcase_nif_init,
+	     NULL, NULL, NULL);
diff --git a/erts/emulator/test/alloc_SUITE_data/bucket_mask.erl b/erts/emulator/test/alloc_SUITE_data/bucket_mask.erl
new file mode 100644
index 0000000000..589a50e1fa
--- /dev/null
+++ b/erts/emulator/test/alloc_SUITE_data/bucket_mask.erl
@@ -0,0 +1,10 @@
+-module(bucket_mask).
+
+-export([init/1, start/1, run/1, stop/1]).
+
+init(File) ->
+    ok = erlang:load_nif(File, 0).
+
+start(_) -> erlang:nif_error(not_loaded).
+run(_)  -> erlang:nif_error(not_loaded).
+stop(_) -> erlang:nif_error(not_loaded).
diff --git a/erts/emulator/test/alloc_SUITE_data/coalesce.c b/erts/emulator/test/alloc_SUITE_data/coalesce.c
index 36710bf7b5..7791409a34 100644
--- a/erts/emulator/test/alloc_SUITE_data/coalesce.c
+++ b/erts/emulator/test/alloc_SUITE_data/coalesce.c
@@ -1,13 +1,14 @@
-/* ``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 via the world wide web 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.
+/* ``Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  * 
  * The Initial Developer of the Original Code is Ericsson Utvecklings AB.
  * Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
@@ -267,7 +268,7 @@ void
 testcase_run(TestCaseState_t *tcs)
 {
     char *argv_org[] = {"-tsmbcs511","-tmmbcs511", "-tsbct512", "-trmbcmt100", "-tas", NULL, NULL};
-    char *alg[] = {"af", "gf", "bf", "aobf", "aoff", "aoffcaobf", NULL};
+    char *alg[] = {"af", "gf", "bf", "aobf", "aoff", "aoffcbf", "aoffcaobf", NULL};
     int i;
 
     for (i = 0; alg[i]; i++) {
@@ -316,3 +317,6 @@ testcase_cleanup(TestCaseState_t *tcs)
     if (tcs->extra)
 	STOP_ALC((Allctr_t *) tcs->extra);
 }
+
+ERL_NIF_INIT(coalesce, testcase_nif_funcs, testcase_nif_init,
+	     NULL, NULL, NULL);
diff --git a/erts/emulator/test/alloc_SUITE_data/coalesce.erl b/erts/emulator/test/alloc_SUITE_data/coalesce.erl
new file mode 100644
index 0000000000..453c726c4e
--- /dev/null
+++ b/erts/emulator/test/alloc_SUITE_data/coalesce.erl
@@ -0,0 +1,10 @@
+-module(coalesce).
+
+-export([init/1, start/1, run/1, stop/1]).
+
+init(File) ->
+    ok = erlang:load_nif(File, 0).
+
+start(_) -> erlang:nif_error(not_loaded).
+run(_)  -> erlang:nif_error(not_loaded).
+stop(_) -> erlang:nif_error(not_loaded).
diff --git a/erts/emulator/test/alloc_SUITE_data/cpool.c b/erts/emulator/test/alloc_SUITE_data/cpool.c
index 276ed7be04..0c41f4d747 100644
--- a/erts/emulator/test/alloc_SUITE_data/cpool.c
+++ b/erts/emulator/test/alloc_SUITE_data/cpool.c
@@ -1,18 +1,19 @@
 /*
  * %CopyrightBegin%
  *
- * Copyright Ericsson AB 2013. All Rights Reserved.
+ * Copyright Ericsson AB 2013-2016. 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/.
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
  *
- * 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.
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  *
  * %CopyrightEnd%
  */
@@ -85,13 +86,13 @@ thread_func(void *arg)
     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]);
+	    (void) 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]);
+	    (void) CPOOL_DELETE(alloc, crr[d]);
 	    if ((d & 0x7) == 0)
 		FATAL_ASSERT(!CPOOL_IS_IN_POOL(alloc, crr[d]));
 	}
@@ -128,7 +129,7 @@ testcase_run(TestCaseState_t *tcs)
 	for (c = 0; c < TEST_NO_CARRIERS_PER_THREAD; c++) {
 	    Carrier_t *crr = (Carrier_t *) p;
 	    p += zcrr_sz;
-	    ZERO_CRR_INIT(alloc, crr);
+	    (void) ZERO_CRR_INIT(alloc, crr);
 	    threads[t].crr[c] = crr;
 	}
     }
@@ -155,3 +156,6 @@ testcase_run(TestCaseState_t *tcs)
 
     ASSERT(tcs, no_threads == TEST_NO_THREADS);
 }
+
+ERL_NIF_INIT(cpool, testcase_nif_funcs, testcase_nif_init,
+	     NULL, NULL, NULL);
diff --git a/erts/emulator/test/alloc_SUITE_data/cpool.erl b/erts/emulator/test/alloc_SUITE_data/cpool.erl
new file mode 100644
index 0000000000..89053471fa
--- /dev/null
+++ b/erts/emulator/test/alloc_SUITE_data/cpool.erl
@@ -0,0 +1,10 @@
+-module(cpool).
+
+-export([init/1, start/1, run/1, stop/1]).
+
+init(File) ->
+    ok = erlang:load_nif(File, 0).
+
+start(_) -> erlang:nif_error(not_loaded).
+run(_)  -> erlang:nif_error(not_loaded).
+stop(_) -> erlang:nif_error(not_loaded).
diff --git a/erts/emulator/test/alloc_SUITE_data/migration.c b/erts/emulator/test/alloc_SUITE_data/migration.c
new file mode 100644
index 0000000000..b9a4de03b3
--- /dev/null
+++ b/erts/emulator/test/alloc_SUITE_data/migration.c
@@ -0,0 +1,343 @@
+/*
+ * %CopyrightBegin%
+ *
+ * Copyright Ericsson AB 2014-2016. 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%
+ */
+
+/*
+ * Test the carrier migration logic
+ */
+
+#ifndef __WIN32__
+#include <sys/types.h>
+#include <unistd.h>
+#include <errno.h>
+#endif
+#include <stdio.h>
+#include <stdlib.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();
+}
+
+
+char *
+testcase_name(void)
+{
+    return "migration";
+}
+
+/* Turns out random_r() is a nonstandard glibc extension.
+#define HAVE_RANDOM_R
+*/
+#ifdef HAVE_RANDOM_R
+
+typedef struct { struct random_data rnd; char rndbuf[32]; } MyRandState;
+
+static void myrand_init(MyRandState* mrs, unsigned int seed)
+{
+    int res;
+    memset(&mrs->rnd, 0, sizeof(mrs->rnd));
+    res = initstate_r(seed, mrs->rndbuf, sizeof(mrs->rndbuf), &mrs->rnd);
+    FATAL_ASSERT(res == 0);
+}
+
+static int myrand(MyRandState* mrs)
+{
+    int32_t x;
+    int res = random_r(&mrs->rnd, &x);
+    FATAL_ASSERT(res == 0);
+    return (int)x;
+}
+
+#else /* !HAVE_RANDOM_R */
+
+typedef unsigned int MyRandState;
+
+static void myrand_init(MyRandState* mrs, unsigned int seed)
+{
+    *mrs = seed;
+}
+
+static int myrand(MyRandState* mrs)
+{
+    /* Taken from rand(3) man page.
+     * Modified to return a full 31-bit value by using low half of *mrs as well.
+     */
+    *mrs = (*mrs) * 1103515245 + 12345;
+    return (int) (((*mrs >> 16) | (*mrs << 16)) & ~(1 << 31));
+}
+
+#endif /* !HAVE_RANDOM_R */
+
+#define MAX_BLOCK_PER_THR 200
+#define BLOCKS_PER_MBC 10
+#define MAX_ROUNDS 10000
+
+typedef struct MyBlock_ {
+    struct MyBlock_* next;
+    struct MyBlock_** prevp;
+} MyBlock;
+
+typedef struct {
+    MyBlock* blockv[MAX_BLOCK_PER_THR];
+    MyRandState rand_state;
+    enum { GROWING, SHRINKING, CLEANUP, DONE } phase;
+    int nblocks;
+    int goal_nblocks;
+    int round;
+    int nr_of_migrations;
+    int nr_of_carriers;
+    int max_blocks_in_mbc;
+    int block_size;
+    int max_nblocks;
+} MigrationState;
+
+typedef struct {
+    ErlNifMutex* mtx;
+    int nblocks;
+    MyBlock* first;
+    MigrationState* employer;
+} MyCrrInfo;
+
+
+static int crr_info_offset = -1;
+static void (*orig_create_mbc_fn)(Allctr_t *allctr, Carrier_t *carrier);
+static void (*orig_destroying_mbc_fn)(Allctr_t *allctr, Carrier_t *carrier);
+
+static void my_creating_mbc(Allctr_t *allctr, Carrier_t *carrier)
+{
+    MyCrrInfo* mci = (MyCrrInfo*) ((char*)carrier + crr_info_offset);
+    if (orig_create_mbc_fn)
+	orig_create_mbc_fn(allctr, carrier);
+
+    mci->mtx = enif_mutex_create("alloc_SUITE.migration");
+    mci->nblocks = 0;
+    mci->first = NULL;
+    mci->employer = NULL;
+}
+
+static void my_destroying_mbc(Allctr_t *allctr, Carrier_t *carrier)
+{
+    MyCrrInfo* mci = (MyCrrInfo*) ((char*)carrier + crr_info_offset);
+
+    FATAL_ASSERT(mci->nblocks == 0);
+    FATAL_ASSERT(mci->first == NULL);
+    enif_mutex_destroy(mci->mtx);
+
+    if (orig_destroying_mbc_fn)
+	orig_destroying_mbc_fn(allctr, carrier);
+}
+
+static int migration_init(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info)
+{
+    void* creating_mbc_arg = (void*)my_creating_mbc;
+    void* destroying_mbc_arg = (void*)my_destroying_mbc;
+
+    if (testcase_nif_init(env, priv_data, load_info))
+	return -1;
+
+    crr_info_offset = SET_TEST_MBC_USER_HEADER(sizeof(MyCrrInfo),
+					       &creating_mbc_arg,
+					       &destroying_mbc_arg);
+    FATAL_ASSERT(crr_info_offset >= 0);
+    orig_create_mbc_fn = creating_mbc_arg;
+    orig_destroying_mbc_fn = destroying_mbc_arg;
+
+    return 0;
+}
+
+static void add_block(MyBlock* p, MigrationState* state)
+{
+    MyCrrInfo* mci = (MyCrrInfo*)((char*)BLK_TO_MBC(UMEM2BLK_TEST(p)) + crr_info_offset);
+
+    enif_mutex_lock(mci->mtx);
+    if (++mci->nblocks > state->max_blocks_in_mbc)
+	state->max_blocks_in_mbc = mci->nblocks;
+    p->next = mci->first;
+    p->prevp = &mci->first;
+    mci->first = p;
+    if (p->next)
+	p->next->prevp = &p->next;
+    if (mci->employer != state) {
+	if (!mci->employer) {
+	    FATAL_ASSERT(mci->nblocks == 1);
+	    state->nr_of_carriers++;
+	}
+	else {
+	    state->nr_of_migrations++;
+	}
+	mci->employer = state;
+    }
+    enif_mutex_unlock(mci->mtx);
+}
+
+static void remove_block(MyBlock* p)
+{
+    MyCrrInfo* mci = (MyCrrInfo*)((char*)BLK_TO_MBC(UMEM2BLK_TEST(p)) + crr_info_offset);
+
+    enif_mutex_lock(mci->mtx);
+    mci->nblocks--;
+    if (p->next)
+	p->next->prevp = p->prevp;
+    *p->prevp = p->next;
+    enif_mutex_unlock(mci->mtx);
+}
+
+static int rand_int(MigrationState* state, int low, int high)
+{
+    int x;
+    FATAL_ASSERT(high >= low);
+    x = myrand(&state->rand_state);
+    return low + (x % (high+1-low));
+}
+
+
+static void do_cleanup(TestCaseState_t *tcs, MigrationState* state)
+{
+    if (state->nblocks == 0) {
+	state->phase = DONE;
+	testcase_printf(tcs, "%d: Done %d rounds", tcs->thr_nr, state->round);
+	testcase_printf(tcs, "%d: Cleanup all blocks", tcs->thr_nr);
+	testcase_printf(tcs, "%d: Empty carriers detected = %d", tcs->thr_nr,
+			state->nr_of_carriers);
+	testcase_printf(tcs, "%d: Migrations detected     = %d", tcs->thr_nr,
+			state->nr_of_migrations);
+	testcase_printf(tcs, "%d: Max blocks in carrier   = %d", tcs->thr_nr,
+			state->max_blocks_in_mbc);
+    }
+    else {
+	state->nblocks--;
+	if (state->blockv[state->nblocks]) {
+	    remove_block(state->blockv[state->nblocks]);
+	    FREE_TEST(state->blockv[state->nblocks]);
+	}
+    }
+}
+
+
+void
+testcase_run(TestCaseState_t *tcs)
+{
+    MigrationState* state = (MigrationState*) tcs->extra;
+
+    if (!tcs->extra) {
+	if (!IS_SMP_ENABLED)
+	    testcase_skipped(tcs, "No SMP support");
+
+	tcs->extra = enif_alloc(sizeof(MigrationState));
+	state = (MigrationState*) tcs->extra;
+	memset(state->blockv, 0, sizeof(state->blockv));
+	myrand_init(&state->rand_state, tcs->thr_nr);
+	state->phase = GROWING;
+	state->nblocks = 0;
+	state->round = 0;
+	state->nr_of_migrations = 0;
+	state->nr_of_carriers = 0;
+	state->max_blocks_in_mbc = 0;
+	state->block_size = GET_TEST_MBC_SIZE() / (BLOCKS_PER_MBC+1);
+	if (MAX_BLOCK_PER_THR * state->block_size < tcs->free_mem) {
+	    state->max_nblocks = MAX_BLOCK_PER_THR;
+	} else {
+	    state->max_nblocks = tcs->free_mem / state->block_size;
+	}
+	state->goal_nblocks = rand_int(state, 1, state->max_nblocks);
+    }
+
+    switch (state->phase) {
+    case GROWING: {
+	MyBlock* p;
+	FATAL_ASSERT(!state->blockv[state->nblocks]);
+	p = ALLOC_TEST(rand_int(state, state->block_size/2, state->block_size));
+	FATAL_ASSERT(p);
+	add_block(p, state);
+	state->blockv[state->nblocks] = p;
+	if (++state->nblocks >= state->goal_nblocks) {
+	    /*testcase_printf(tcs, "%d: Grown to %d blocks", tcs->thr_nr, state->nblocks);*/
+	    state->phase = SHRINKING;
+	    state->goal_nblocks = rand_int(state, 0, state->goal_nblocks-1);
+	}
+	else
+	    FATAL_ASSERT(!state->blockv[state->nblocks]);
+	break;
+    }
+    case SHRINKING: {
+	int ix = rand_int(state, 0, state->nblocks-1);
+	FATAL_ASSERT(state->blockv[ix]);
+	remove_block(state->blockv[ix]);
+	FREE_TEST(state->blockv[ix]);
+	state->blockv[ix] = state->blockv[--state->nblocks];
+	state->blockv[state->nblocks] = NULL;
+
+	if (state->nblocks <= state->goal_nblocks) {
+	    /*testcase_printf(tcs, "%d: Shrunk to %d blocks", tcs->thr_nr, state->nblocks);*/
+	    if (++state->round >= MAX_ROUNDS) {
+		state->phase = CLEANUP;
+	    } else {
+		state->phase = GROWING;
+		state->goal_nblocks = rand_int(state, state->goal_nblocks+1, state->max_nblocks);
+	    }
+	}
+	break;
+    }
+    case CLEANUP:
+	do_cleanup(tcs, state);
+	break;
+
+    default:
+	FATAL_ASSERT(!"Invalid phase");
+    }
+
+    if (state->phase == DONE) {
+    }
+    else {
+	testcase_continue(tcs);
+    }
+}
+
+void
+testcase_cleanup(TestCaseState_t *tcs)
+{
+    MigrationState* state = (MigrationState*) tcs->extra;
+
+    while (state->phase != DONE)
+	do_cleanup(tcs, state);
+
+    enif_free(tcs->extra);
+    tcs->extra = NULL;
+}
+
+
+ERL_NIF_INIT(migration, testcase_nif_funcs, migration_init,
+	     NULL, NULL, NULL);
diff --git a/erts/emulator/test/alloc_SUITE_data/migration.erl b/erts/emulator/test/alloc_SUITE_data/migration.erl
new file mode 100644
index 0000000000..440a99becd
--- /dev/null
+++ b/erts/emulator/test/alloc_SUITE_data/migration.erl
@@ -0,0 +1,10 @@
+-module(migration).
+
+-export([init/1, start/1, run/1, stop/1]).
+
+init(File) ->
+    ok = erlang:load_nif(File, 0).
+
+start(_) -> erlang:nif_error(not_loaded).
+run(_)  -> erlang:nif_error(not_loaded).
+stop(_) -> erlang:nif_error(not_loaded).
diff --git a/erts/emulator/test/alloc_SUITE_data/mseg_clear_cache.c b/erts/emulator/test/alloc_SUITE_data/mseg_clear_cache.c
index 7d5608f890..e5df3d647f 100644
--- a/erts/emulator/test/alloc_SUITE_data/mseg_clear_cache.c
+++ b/erts/emulator/test/alloc_SUITE_data/mseg_clear_cache.c
@@ -1,13 +1,14 @@
-/* ``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 via the world wide web 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.
+/* ``Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  * 
  * The Initial Developer of the Original Code is Ericsson Utvecklings AB.
  * Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
@@ -100,3 +101,6 @@ testcase_cleanup(TestCaseState_t *tcs)
 	tcs->extra = NULL;
     }
 }
+
+ERL_NIF_INIT(mseg_clear_cache, testcase_nif_funcs, testcase_nif_init,
+	     NULL, NULL, NULL);
diff --git a/erts/emulator/test/alloc_SUITE_data/mseg_clear_cache.erl b/erts/emulator/test/alloc_SUITE_data/mseg_clear_cache.erl
new file mode 100644
index 0000000000..befd6c2e8e
--- /dev/null
+++ b/erts/emulator/test/alloc_SUITE_data/mseg_clear_cache.erl
@@ -0,0 +1,10 @@
+-module(mseg_clear_cache).
+
+-export([init/1, start/1, run/1, stop/1]).
+
+init(File) ->
+    ok = erlang:load_nif(File, 0).
+
+start(_) -> erlang:nif_error(not_loaded).
+run(_)  -> erlang:nif_error(not_loaded).
+stop(_) -> erlang:nif_error(not_loaded).
diff --git a/erts/emulator/test/alloc_SUITE_data/rbtree.c b/erts/emulator/test/alloc_SUITE_data/rbtree.c
index 702f075304..38bbbdf90c 100644
--- a/erts/emulator/test/alloc_SUITE_data/rbtree.c
+++ b/erts/emulator/test/alloc_SUITE_data/rbtree.c
@@ -1,13 +1,14 @@
-/* ``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 via the world wide web 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.
+/* ``Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  * 
  * The Initial Developer of the Original Code is Ericsson Utvecklings AB.
  * Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
@@ -19,7 +20,7 @@
 #include "testcase_driver.h"
 #include "allocator_test.h"
 
-#define NO_BLOCKS 100000
+int NO_BLOCKS;
 
 #define RIGHT_VISITED (1 << 0)
 #define LEFT_VISITED (1 << 1)
@@ -85,23 +86,21 @@ 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, AOFFCAOBF }type;
+    enum { BF, AOBF, AOFF } type;
     int i, max_i;
     char stk[128];
     RBT_t *root, *x, *y, *res;
     Ulong x_sz, y_sz, is_x_black;
     long blacks, curr_blacks;
+    int have_max_sz;
 
     res = NULL;
 
-    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;
-    }
+    if (IS_AOBF(alc)) type = AOBF;
+    else if (IS_BF(alc)) type = BF;
+    else type = AOFF;
+
+    have_max_sz = !IS_BF_ALGO(alc);
 
     root = RBT_ROOT(alc, size);
 
@@ -191,17 +190,10 @@ check_tree(TestCaseState_t *tcs, Allctr_t *alc, Ulong size)
 		break;
 	    case AOFF:
 		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;
-		}
+	    }
+	    if (have_max_sz) {
+		ASSERT(tcs, RBT_MAX_SZ(y) <= RBT_MAX_SZ(x));
 	    }
 	}
 
@@ -219,27 +211,22 @@ check_tree(TestCaseState_t *tcs, Allctr_t *alc, Ulong size)
 		break;
 	    case AOFF:
 		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;
-		}
+	    }
+	    if (have_max_sz) {
+		ASSERT(tcs, RBT_MAX_SZ(y) <= RBT_MAX_SZ(x));
 	    }
 	}
 
 	if (type == BF) {
 	    Ulong l_sz;
-	    RBTL_t *l = RBT_NEXT(x);
+	    RBTL_t *l, *prev=x;
 	    for (l = RBT_NEXT(x); l; l = RBT_NEXT(l)) {
 		l_sz = BLK_SZ(l);
 		ASSERT(tcs, l_sz == x_sz);
 		ASSERT(tcs, !RBT_IS_TREE(l));
+		ASSERT(tcs, RBT_PREV(l) == prev);
+		prev = l;
 	    }
 	}
 
@@ -262,18 +249,7 @@ 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;
 		}
-
 	    }
 	}
 
@@ -289,9 +265,10 @@ check_tree(TestCaseState_t *tcs, Allctr_t *alc, Ulong size)
     ASSERT(tcs, curr_blacks == 0);
     ASSERT(tcs, i == -1);
 
+    /*
     testcase_printf(tcs, "Red-Black Tree OK! Max depth = %d; "
 		    "Black depth = %d\n", max_i+1, blacks < 0 ? 0 : blacks);
-
+    */
     return res;
 
 }
@@ -310,7 +287,7 @@ do_check(TestCaseState_t *tcs, Allctr_t *a, Ulong size, int ignore_null)
     tmp = ALLOC(a, sz - ABLK_HDR_SZ);
     ASSERT(tcs, tmp);
     y = UMEM2BLK(tmp);
-    if (!(IS_BF_ALGO(a) && !IS_AOBF(a))) {
+    if (!IS_BF(a)) {
 	ASSERT(tcs, x == y);
     }
     else {
@@ -488,9 +465,16 @@ testcase_run(TestCaseState_t *tcs)
     char *argv2[] = {"-tasaobf", NULL};
     char *argv3[] = {"-tasaoff", NULL};
     char *argv4[] = {"-tasaoffcaobf", NULL};
+    char *argv5[] = {"-tasaoffcbf", NULL};
     Allctr_t *a;
     rbtree_test_data *td;
 
+    NO_BLOCKS = 100*1000;
+    if (enif_is_identical(tcs->build_type,
+                          enif_make_atom(tcs->curr_env,"valgrind"))) {
+        NO_BLOCKS /= 10;
+    }
+
     /* Best fit... */
 
     testcase_printf(tcs, "Setup...\n");
@@ -511,6 +495,7 @@ testcase_run(TestCaseState_t *tcs)
     ASSERT(tcs, a);
     ASSERT(tcs, IS_BF_ALGO(a));
     ASSERT(tcs, !IS_AOBF(a));
+    ASSERT(tcs, IS_BF(a));
 
     test_it(tcs);
 
@@ -529,6 +514,7 @@ testcase_run(TestCaseState_t *tcs)
     ASSERT(tcs, a);
     ASSERT(tcs, IS_BF_ALGO(a));
     ASSERT(tcs, IS_AOBF(a));
+    ASSERT(tcs, !IS_BF(a));
 
     test_it(tcs);
 
@@ -546,7 +532,8 @@ testcase_run(TestCaseState_t *tcs)
 
     ASSERT(tcs, a);
     ASSERT(tcs, !IS_BF_ALGO(a));
-    ASSERT(tcs, !IS_CBF(a));
+    ASSERT(tcs, !IS_AOBF(a));
+    ASSERT(tcs, !IS_BF(a));
 
     test_it(tcs);
     test_carrier_migration(tcs);
@@ -556,7 +543,7 @@ testcase_run(TestCaseState_t *tcs)
 
     testcase_printf(tcs, "Address order first fit test succeeded!\n");
 
-    /* Address order first fit, best fit within carrier */
+    /* Address order first fit, aobf within carrier */
 
     testcase_printf(tcs, "Starting test of aoffcaobf...\n");
 
@@ -565,7 +552,28 @@ testcase_run(TestCaseState_t *tcs)
 
     ASSERT(tcs, a);
     ASSERT(tcs, !IS_BF_ALGO(a));
-    ASSERT(tcs, IS_CBF(a));
+    ASSERT(tcs, IS_AOBF(a));
+    ASSERT(tcs, !IS_BF(a));
+
+    test_it(tcs);
+    test_carrier_migration(tcs);
+
+    STOP_ALC(a);
+    td->allocator = NULL;
+
+    testcase_printf(tcs, "aoffcaobf test succeeded!\n");
+
+    /* Address order first fit, bf within carrier */
+
+    testcase_printf(tcs, "Starting test of aoffcbf...\n");
+
+    current_rbt_type_op_base = AO_FIRSTFIT_OP_BASE;
+    td->allocator = a = START_ALC("rbtree_aoffcbf_", 0, argv5);
+
+    ASSERT(tcs, a);
+    ASSERT(tcs, !IS_BF_ALGO(a));
+    ASSERT(tcs, !IS_AOBF(a));
+    ASSERT(tcs, IS_BF(a));
 
     test_it(tcs);
     test_carrier_migration(tcs);
@@ -576,3 +584,6 @@ testcase_run(TestCaseState_t *tcs)
     testcase_printf(tcs, "aoffcaobf test succeeded!\n");
 
 }
+
+ERL_NIF_INIT(rbtree, testcase_nif_funcs, testcase_nif_init,
+	     NULL, NULL, NULL);
diff --git a/erts/emulator/test/alloc_SUITE_data/rbtree.erl b/erts/emulator/test/alloc_SUITE_data/rbtree.erl
new file mode 100644
index 0000000000..f5b7120ff2
--- /dev/null
+++ b/erts/emulator/test/alloc_SUITE_data/rbtree.erl
@@ -0,0 +1,10 @@
+-module(rbtree).
+
+-export([init/1, start/1, run/1, stop/1]).
+
+init(File) ->
+    ok = erlang:load_nif(File, 0).
+
+start(_) -> erlang:nif_error(not_loaded).
+run(_)  -> erlang:nif_error(not_loaded).
+stop(_) -> erlang:nif_error(not_loaded).
diff --git a/erts/emulator/test/alloc_SUITE_data/realloc_copy.c b/erts/emulator/test/alloc_SUITE_data/realloc_copy.c
index 12454c75e4..c4147eb00d 100644
--- a/erts/emulator/test/alloc_SUITE_data/realloc_copy.c
+++ b/erts/emulator/test/alloc_SUITE_data/realloc_copy.c
@@ -1,13 +1,14 @@
-/* ``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 via the world wide web 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.
+/* ``Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  * 
  * The Initial Developer of the Original Code is Ericsson Utvecklings AB.
  * Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
@@ -277,3 +278,5 @@ testcase_cleanup(TestCaseState_t *tcs)
 	STOP_ALC((Allctr_t *) tcs->extra);
 }
 
+ERL_NIF_INIT(realloc_copy, testcase_nif_funcs, testcase_nif_init,
+	     NULL, NULL, NULL);
diff --git a/erts/emulator/test/alloc_SUITE_data/realloc_copy.erl b/erts/emulator/test/alloc_SUITE_data/realloc_copy.erl
new file mode 100644
index 0000000000..cc6617bf64
--- /dev/null
+++ b/erts/emulator/test/alloc_SUITE_data/realloc_copy.erl
@@ -0,0 +1,10 @@
+-module(realloc_copy).
+
+-export([init/1, start/1, run/1, stop/1]).
+
+init(File) ->
+    ok = erlang:load_nif(File, 0).
+
+start(_) -> erlang:nif_error(not_loaded).
+run(_)  -> erlang:nif_error(not_loaded).
+stop(_) -> erlang:nif_error(not_loaded).
diff --git a/erts/emulator/test/alloc_SUITE_data/testcase_driver.c b/erts/emulator/test/alloc_SUITE_data/testcase_driver.c
index 5c4b11454f..7dcca544e5 100644
--- a/erts/emulator/test/alloc_SUITE_data/testcase_driver.c
+++ b/erts/emulator/test/alloc_SUITE_data/testcase_driver.c
@@ -1,13 +1,14 @@
-/* ``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 via the world wide web 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.
+/* ``Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  * 
  * The Initial Developer of the Original Code is Ericsson Utvecklings AB.
  * Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
@@ -22,141 +23,147 @@
 #include <stdarg.h>
 #include <setjmp.h>
 #include <string.h>
+#include <limits.h>
 
 #ifdef __WIN32__
-#undef HAVE_VSNPRINTF
-#define HAVE_VSNPRINTF 1
-#define vsnprintf _vsnprintf
+static void my_vsnprintf(char *outBuf, size_t size, const char *format, va_list ap)
+{
+    _vsnprintf(outBuf, size, format, ap);
+    outBuf[size-1] = 0;  /* be sure string is terminated */
+}
+#elif defined(HAVE_VSNPRINTF)
+#  define my_vsnprintf(B,S,F,A) (void)vsnprintf(B,S,F,A)
+#else
+#  warning Using unsafe 'vsprintf' without buffer overflow protection
+#  define my_vsnprintf(B,S,F,A) (void)vsprintf(B,F,A)
 #endif
 
-#ifndef HAVE_VSNPRINTF
-#define HAVE_VSNPRINTF 0
-#endif
+static void my_snprintf(char *outBuf, size_t size, const char *format, ...)
+{
+    va_list ap;
+    va_start(ap, format);
+    my_vsnprintf(outBuf, size, format, ap);
+    va_end(ap);
+}
 
 #define COMMENT_BUF_SZ 4096
 
 #define TESTCASE_FAILED		0
 #define TESTCASE_SKIPPED	1
 #define TESTCASE_SUCCEEDED	2
+#define TESTCASE_CONTINUE	3
 
 typedef struct {
     TestCaseState_t visible;
-    ErlDrvPort port;
-    ErlDrvTermData  port_id;
     int result;
-    jmp_buf done_jmp_buf;
+    jmp_buf* done_jmp_buf;
     char *comment;
     char comment_buf[COMMENT_BUF_SZ];
 } InternalTestCaseState_t;
 
-ErlDrvData testcase_drv_start(ErlDrvPort port, char *command);
-void testcase_drv_stop(ErlDrvData drv_data);
-void testcase_drv_run(ErlDrvData drv_data, char *buf, ErlDrvSizeT len);
-
-static ErlDrvEntry testcase_drv_entry = { 
-    NULL,
-    testcase_drv_start,
-    testcase_drv_stop,
-    testcase_drv_run,
-    NULL,
-    NULL,
-    "testcase_drv",
-    NULL,
-    NULL,
-    NULL,
-    NULL,
-    NULL,
-    NULL,
-    NULL,
-    NULL,
-    NULL,
-    ERL_DRV_EXTENDED_MARKER,
-    ERL_DRV_EXTENDED_MAJOR_VERSION,
-    ERL_DRV_EXTENDED_MINOR_VERSION,
-    0,
-    NULL,
-    NULL,
-    NULL
+ERL_NIF_TERM testcase_nif_start(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
+ERL_NIF_TERM testcase_nif_stop(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
+ERL_NIF_TERM testcase_nif_run(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[]);
+
+ErlNifFunc testcase_nif_funcs[] =
+{
+    {"start", 1, testcase_nif_start},
+    {"run", 1, testcase_nif_run},
+    {"stop", 1, testcase_nif_stop}
 };
 
+static ErlNifResourceType* testcase_rt;
+static ERL_NIF_TERM print_atom;
 
-DRIVER_INIT(testcase_drv)
+int testcase_nif_init(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info)
 {
-    testcase_drv_entry.driver_name = testcase_name();
-    return &testcase_drv_entry;
+    testcase_rt = enif_open_resource_type(env, NULL, "testcase_rt", NULL,
+					  ERL_NIF_RT_CREATE, NULL);
+
+    print_atom = enif_make_atom(env, "print");
+    return 0;
 }
 
-ErlDrvData
-testcase_drv_start(ErlDrvPort port, char *command)
-{
+ERL_NIF_TERM
+testcase_nif_start(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
+{ /* (ThrNr, FreeMeg, BuildType) */
+    ERL_NIF_TERM ret;
     InternalTestCaseState_t *itcs = (InternalTestCaseState_t *)
-	driver_alloc(sizeof(InternalTestCaseState_t));
-    if (!itcs) {
-	return ERL_DRV_ERROR_GENERAL;
+             enif_alloc_resource(testcase_rt, sizeof(InternalTestCaseState_t));
+    int free_megabyte;
+    const int max_megabyte = INT_MAX / (1024*1024);
+    const ERL_NIF_TERM* tpl;
+    int tpl_arity;
+
+    if (!itcs
+        || !enif_get_tuple(env, argv[0], &tpl_arity, &tpl)
+        || tpl_arity != 3
+	|| !enif_get_int(env, tpl[0], &itcs->visible.thr_nr)
+	|| !enif_get_int(env, tpl[1], &free_megabyte)) {
+	enif_make_badarg(env);
     }
-
+    itcs->visible.free_mem = (free_megabyte < max_megabyte ?
+                              free_megabyte : max_megabyte) * (1024*1024);
     itcs->visible.testcase_name = testcase_name();
+    itcs->visible.build_type = tpl[2];
     itcs->visible.extra = NULL;
-    itcs->port = port;
-    itcs->port_id = driver_mk_port(port);
     itcs->result = TESTCASE_FAILED;
     itcs->comment = "";
 
-    return (ErlDrvData) itcs;
+    ret = enif_make_resource(env, itcs);
+    enif_release_resource(itcs);
+    return ret;
 }
 
-void
-testcase_drv_stop(ErlDrvData drv_data)
+ERL_NIF_TERM
+testcase_nif_stop(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {
-    testcase_cleanup((TestCaseState_t *) drv_data);
-    driver_free((void *) drv_data);
+    InternalTestCaseState_t *itcs;
+    if (!enif_get_resource(env, argv[0], testcase_rt, (void**)&itcs))
+	return enif_make_badarg(env);
+    testcase_cleanup(&itcs->visible);
+    return enif_make_atom(env,"ok");
 }
 
-void
-testcase_drv_run(ErlDrvData drv_data, char *buf, ErlDrvSizeT len)
+ERL_NIF_TERM
+testcase_nif_run(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {
-    InternalTestCaseState_t *itcs = (InternalTestCaseState_t *) drv_data;
-    ErlDrvTermData result_atom;
-    ErlDrvTermData msg[12];
+    InternalTestCaseState_t *itcs;
+    const char* result_atom;
+    jmp_buf the_jmp_buf;
 
-    itcs->visible.command = buf;
-    itcs->visible.command_len = len;
+    if (!enif_get_resource(env, argv[0], testcase_rt, (void**)&itcs))
+	return enif_make_badarg(env);
 
-    if (setjmp(itcs->done_jmp_buf) == 0) {
-	testcase_run((TestCaseState_t *) itcs);
+    itcs->visible.curr_env = env;
+
+    /* For some unknown reason, first call to setjmp crashes on win64
+     * when jmp_buf is allocated as part of the resource. But it works when
+     * allocated on stack. It used to work when this was a driver.
+     */
+    itcs->done_jmp_buf = &the_jmp_buf;
+
+    if (setjmp(the_jmp_buf) == 0) {
+	testcase_run(&itcs->visible);
 	itcs->result = TESTCASE_SUCCEEDED;
     }
 
     switch (itcs->result) {
-    case TESTCASE_SUCCEEDED:
-	result_atom = driver_mk_atom("succeeded");
-	break;
-    case TESTCASE_SKIPPED:
-	result_atom = driver_mk_atom("skipped");
-	break;
-    case TESTCASE_FAILED:
+    case TESTCASE_CONTINUE:
+	return enif_make_atom(env, "continue");
+
+    case TESTCASE_SUCCEEDED: result_atom = "succeeded"; break;
+    case TESTCASE_SKIPPED: result_atom = "skipped"; break;
+    case TESTCASE_FAILED: result_atom = "failed"; break;
     default:
-	result_atom = driver_mk_atom("failed");
-	break;
+        result_atom = "failed";
+        my_snprintf(itcs->comment_buf, sizeof(itcs->comment_buf),
+		    "Unexpected test result code %d.", itcs->result);
+        itcs->comment = itcs->comment_buf;
     }
 
-    msg[0] = ERL_DRV_ATOM;
-    msg[1] = (ErlDrvTermData) result_atom;
-
-    msg[2] = ERL_DRV_PORT;
-    msg[3] = itcs->port_id;
-
-    msg[4] = ERL_DRV_ATOM;
-    msg[5] = driver_mk_atom(itcs->visible.testcase_name);
- 
-    msg[6] = ERL_DRV_STRING;
-    msg[7] = (ErlDrvTermData) itcs->comment;
-    msg[8] = (ErlDrvTermData) strlen(itcs->comment);
-
-    msg[9] = ERL_DRV_TUPLE;
-    msg[10] = (ErlDrvTermData) 4;
-
-    erl_drv_output_term(itcs->port_id, msg, 11);
+    return enif_make_tuple2(env, enif_make_atom(env, result_atom),
+			    enif_make_string(env, itcs->comment, ERL_NIF_LATIN1));
 }
 
 int
@@ -171,34 +178,22 @@ testcase_assertion_failed(TestCaseState_t *tcs,
 void
 testcase_printf(TestCaseState_t *tcs, char *frmt, ...)
 {
-    InternalTestCaseState_t *itcs = (InternalTestCaseState_t *) tcs;
-    ErlDrvTermData msg[12];
+    InternalTestCaseState_t* itcs = (InternalTestCaseState_t*)tcs;
+    ErlNifPid pid;
+    ErlNifEnv* msg_env = enif_alloc_env();
+    ERL_NIF_TERM msg;
     va_list va;
     va_start(va, frmt);
-#if HAVE_VSNPRINTF
-    vsnprintf(itcs->comment_buf, COMMENT_BUF_SZ, frmt, va);
-#else
-    vsprintf(itcs->comment_buf, frmt, va);
-#endif
+    my_vsnprintf(itcs->comment_buf, COMMENT_BUF_SZ, frmt, va);
     va_end(va);
 
-    msg[0] = ERL_DRV_ATOM;
-    msg[1] = (ErlDrvTermData) driver_mk_atom("print");
-
-    msg[2] = ERL_DRV_PORT;
-    msg[3] = itcs->port_id;
-
-    msg[4] = ERL_DRV_ATOM;
-    msg[5] = driver_mk_atom(itcs->visible.testcase_name);
+    msg = enif_make_tuple2(msg_env, print_atom,
+		    enif_make_string(msg_env, itcs->comment_buf, ERL_NIF_LATIN1));
 
-    msg[6] = ERL_DRV_STRING;
-    msg[7] = (ErlDrvTermData) itcs->comment_buf;
-    msg[8] = (ErlDrvTermData) strlen(itcs->comment_buf);
+    enif_send(itcs->visible.curr_env, enif_self(itcs->visible.curr_env, &pid),
+	      msg_env, msg);
 
-    msg[9] = ERL_DRV_TUPLE;
-    msg[10] = (ErlDrvTermData) 4;
-
-    erl_drv_output_term(itcs->port_id, msg, 11);
+    enif_free_env(msg_env);
 }
 
 
@@ -207,17 +202,13 @@ void testcase_succeeded(TestCaseState_t *tcs, char *frmt, ...)
     InternalTestCaseState_t *itcs = (InternalTestCaseState_t *) tcs;
     va_list va;
     va_start(va, frmt);
-#if HAVE_VSNPRINTF
-    vsnprintf(itcs->comment_buf, COMMENT_BUF_SZ, frmt, va);
-#else
-    vsprintf(itcs->comment_buf, frmt, va);
-#endif
+    my_vsnprintf(itcs->comment_buf, COMMENT_BUF_SZ, frmt, va);
     va_end(va);
 
     itcs->result = TESTCASE_SUCCEEDED;
     itcs->comment = itcs->comment_buf;
 
-    longjmp(itcs->done_jmp_buf, 1);
+    longjmp(*itcs->done_jmp_buf, 1);
 }
 
 void testcase_skipped(TestCaseState_t *tcs, char *frmt, ...)
@@ -225,17 +216,20 @@ void testcase_skipped(TestCaseState_t *tcs, char *frmt, ...)
     InternalTestCaseState_t *itcs = (InternalTestCaseState_t *) tcs;
     va_list va;
     va_start(va, frmt);
-#if HAVE_VSNPRINTF
-    vsnprintf(itcs->comment_buf, COMMENT_BUF_SZ, frmt, va);
-#else
-    vsprintf(itcs->comment_buf, frmt, va);
-#endif
+    my_vsnprintf(itcs->comment_buf, COMMENT_BUF_SZ, frmt, va);
     va_end(va);
 
     itcs->result = TESTCASE_SKIPPED;
     itcs->comment = itcs->comment_buf;
 
-    longjmp(itcs->done_jmp_buf, 1);
+    longjmp(*itcs->done_jmp_buf, 1);
+}
+
+void testcase_continue(TestCaseState_t *tcs)
+{
+    InternalTestCaseState_t *itcs = (InternalTestCaseState_t *) tcs;
+    itcs->result = TESTCASE_CONTINUE;
+    longjmp(*itcs->done_jmp_buf, 1);
 }
 
 void testcase_failed(TestCaseState_t *tcs, char *frmt, ...)
@@ -245,37 +239,33 @@ void testcase_failed(TestCaseState_t *tcs, char *frmt, ...)
     size_t bufsz = sizeof(buf);
     va_list va;
     va_start(va, frmt);
-#if HAVE_VSNPRINTF
-    vsnprintf(itcs->comment_buf, COMMENT_BUF_SZ, frmt, va);
-#else
-    vsprintf(itcs->comment_buf, frmt, va);
-#endif
+    my_vsnprintf(itcs->comment_buf, COMMENT_BUF_SZ, frmt, va);
     va_end(va);
 
     itcs->result = TESTCASE_FAILED;
     itcs->comment = itcs->comment_buf;
 
-    if (erl_drv_getenv("ERL_ABORT_ON_FAILURE", buf, &bufsz) == 0
+    if (enif_getenv("ERL_ABORT_ON_FAILURE", buf, &bufsz) == 0
 	&& strcmp("true", buf) == 0) {
 	fprintf(stderr, "Testcase \"%s\" failed: %s\n",
 		itcs->visible.testcase_name, itcs->comment);
 	abort();
     }
 
-    longjmp(itcs->done_jmp_buf, 1);
+    longjmp(*itcs->done_jmp_buf, 1);
 }
 
 void *testcase_alloc(size_t size)
 {
-    return driver_alloc(size);
+    return enif_alloc(size);
 }
 
 void *testcase_realloc(void *ptr, size_t size)
 {
-    return driver_realloc(ptr, size);
+    return enif_realloc(ptr, size);
 }
 
 void testcase_free(void *ptr)
 {
-    driver_free(ptr);
+    enif_free(ptr);
 }
diff --git a/erts/emulator/test/alloc_SUITE_data/testcase_driver.h b/erts/emulator/test/alloc_SUITE_data/testcase_driver.h
index 66d567cb44..f0ca91bd06 100644
--- a/erts/emulator/test/alloc_SUITE_data/testcase_driver.h
+++ b/erts/emulator/test/alloc_SUITE_data/testcase_driver.h
@@ -1,13 +1,14 @@
-/* ``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 via the world wide web 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.
+/* ``Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  * 
  * The Initial Developer of the Original Code is Ericsson Utvecklings AB.
  * Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
@@ -19,13 +20,15 @@
 #ifndef TESTCASE_DRIVER_H__
 #define TESTCASE_DRIVER_H__
 
-#include "erl_driver.h"
+#include "erl_nif.h"
 #include <stdlib.h>
 
 typedef struct {
+    ErlNifEnv* curr_env;
     char *testcase_name;
-    char *command;
-    int command_len;
+    int thr_nr;
+    int free_mem; /* in bytes */
+    ERL_NIF_TERM build_type;  /* opt, debug, valgrind, ... */
     void *extra;
 } TestCaseState_t;
 
@@ -33,9 +36,11 @@ typedef struct {
   ((void) ((B) ? 1 : testcase_assertion_failed((TCS), __FILE__, __LINE__, #B)))
 
 
+int testcase_nif_init(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info);
 void testcase_printf(TestCaseState_t *tcs, char *frmt, ...);
 void testcase_succeeded(TestCaseState_t *tcs, char *frmt, ...);
 void testcase_skipped(TestCaseState_t *tcs, char *frmt, ...);
+void testcase_continue(TestCaseState_t *tcs);
 void testcase_failed(TestCaseState_t *tcs, char *frmt, ...);
 int testcase_assertion_failed(TestCaseState_t *tcs, char *file, int line,
 			      char *assertion);
@@ -44,8 +49,11 @@ void *testcase_realloc(void *ptr, size_t size);
 void testcase_free(void *ptr);
 
 
+/* Implemented by testcase: */
 char *testcase_name(void);
 void testcase_run(TestCaseState_t *tcs);
 void testcase_cleanup(TestCaseState_t *tcs);
 
-#endif
+extern ErlNifFunc testcase_nif_funcs[3];
+
+#endif /* TESTCASE_DRIVER_H__ */
diff --git a/erts/emulator/test/alloc_SUITE_data/threads.c b/erts/emulator/test/alloc_SUITE_data/threads.c
index 1247e5d7dd..44d982b6c7 100644
--- a/erts/emulator/test/alloc_SUITE_data/threads.c
+++ b/erts/emulator/test/alloc_SUITE_data/threads.c
@@ -1,13 +1,14 @@
-/* ``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 via the world wide web 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.
+/* ``Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
  * 
  * The Initial Developer of the Original Code is Ericsson Utvecklings AB.
  * Portions created by Ericsson are Copyright 1999, Ericsson Utvecklings
@@ -85,7 +86,7 @@ static void fail(int t_no, char *frmt, ...)
 
     tc_failed = 1;
 
-    if (erl_drv_getenv("ERL_ABORT_ON_FAILURE", buf, &bufsz) == 0
+    if (enif_getenv("ERL_ABORT_ON_FAILURE", buf, &bufsz) == 0
 	&& strcmp("true", buf) == 0) {
 	fprintf(stderr, "Testcase \"%s\" failed: %s\n",
 		testcase_name(), err_buf);
@@ -95,16 +96,11 @@ static void fail(int t_no, char *frmt, ...)
     exit_thread(t_no, 0);
 }
 
-static Allctr_t *alloc_not_ts = NULL;
 static Allctr_t *alloc_ts_1 = NULL;
 static Allctr_t *alloc_ts_2 = NULL;
 
 static void stop_allocators(void)
 {
-    if (alloc_not_ts) {
-	STOP_ALC(alloc_not_ts);
-	alloc_not_ts = NULL;
-    }
     if (alloc_ts_1) {
 	STOP_ALC(alloc_ts_1);
 	alloc_ts_1 = NULL;
@@ -154,7 +150,6 @@ testcase_run(TestCaseState_t *tcs)
     if (!IS_THREADS_ENABLED)
 	testcase_skipped(tcs, "Threads not enabled");
 
-    alloc_not_ts = NULL;
     alloc_ts_1 = NULL;
     alloc_ts_2 = NULL;
 
@@ -163,16 +158,12 @@ testcase_run(TestCaseState_t *tcs)
     sprintf(sbct_buf, "%d", SBC_THRESHOLD/1024);
     
     memcpy((void *) argv, argv_org, sizeof(argv_org));
-    alloc_not_ts = START_ALC("threads_not_ts", 0, argv);
-    ASSERT(tcs, alloc_not_ts);
-    memcpy((void *) argv, argv_org, sizeof(argv_org));
     alloc_ts_1 = START_ALC("threads_ts_1", 1, argv);
     ASSERT(tcs, alloc_ts_1);
     memcpy((void *) argv, argv_org, sizeof(argv_org));
     alloc_ts_2 = START_ALC("threads_ts_2", 1, argv);
     ASSERT(tcs, alloc_ts_2);
 
-    ASSERT(tcs, !IS_ALLOC_THREAD_SAFE(alloc_not_ts));
     ASSERT(tcs, IS_ALLOC_THREAD_SAFE(alloc_ts_1));
     ASSERT(tcs, IS_ALLOC_THREAD_SAFE(alloc_ts_2));
 
@@ -186,16 +177,10 @@ testcase_run(TestCaseState_t *tcs)
 
     for(i = 1; i <= NO_OF_THREADS; i++) {
 	char *alc;
-	int res;
 
 	threads[i].arg.no_ops_per_bl = NO_OF_OPS_PER_BL;
 
-	if (i == 1) {
-	    alc = "threads_not_ts";
-	    threads[i].arg.no_ops_per_bl *= 2;
-	    threads[i].arg.a = alloc_not_ts;
-	}
-	else if (i % 2 == 0) {
+	if (i % 2 == 0) {
 	    alc = "threads_ts_1";
 	    threads[i].arg.a = alloc_ts_1;
 	}
@@ -396,7 +381,7 @@ alloc_op(int t_no, Allctr_t *a, block *bp, int id, int clean_up)
 	bp->p = (unsigned char *) ALLOC(a, bp->s);
 	if(!bp->p)
 	    fail(t_no, "ALLOC(%lu) failed [id=%d])\n", bp->s, id);
-	memset((void *) bp->p, id, (size_t) bp->s);
+	memset((void *) bp->p, (unsigned char)id, (size_t) bp->s);
     }
     else {
 	unsigned char *p = (unsigned char *) REALLOC(a, bp->p, bp->as[bp->i]);
@@ -406,7 +391,7 @@ alloc_op(int t_no, Allctr_t *a, block *bp, int id, int clean_up)
 
 	if(bp->s < bp->as[bp->i]) {
 	    CHECK_BLOCK_DATA(t_no, p, bp->s, id);
-	    memset((void *) p, id, (size_t) bp->as[bp->i]);
+	    memset((void *) p, (unsigned char)id, (size_t) bp->as[bp->i]);
 	}
 	else
 	    CHECK_BLOCK_DATA(t_no, p, bp->as[bp->i], id);
@@ -445,3 +430,6 @@ thread_func(void *arg)
     exit_thread(td->t_no, 1);
     return NULL;
 }
+
+ERL_NIF_INIT(threads, testcase_nif_funcs, testcase_nif_init,
+	     NULL, NULL, NULL);
diff --git a/erts/emulator/test/alloc_SUITE_data/threads.erl b/erts/emulator/test/alloc_SUITE_data/threads.erl
new file mode 100644
index 0000000000..a7b4965f5e
--- /dev/null
+++ b/erts/emulator/test/alloc_SUITE_data/threads.erl
@@ -0,0 +1,10 @@
+-module(threads).
+
+-export([init/1, start/1, run/1, stop/1]).
+
+init(File) ->
+    ok = erlang:load_nif(File, 0).
+
+start(_) -> erlang:nif_error(not_loaded).
+run(_)  -> erlang:nif_error(not_loaded).
+stop(_) -> erlang:nif_error(not_loaded).