From 5d67cc7f4c176ea6ab4d2538443d5fe264152861 Mon Sep 17 00:00:00 2001
From: Sverker Eriksson <sverker@erlang.org>
Date: Wed, 19 Jun 2013 18:34:56 +0200
Subject: erts: Add new allocator strategy aoffcbf

with better performance than aoffcaobf as we don't have to rearrange
the search tree when there are blocks of equal size.
---
 .../test/alloc_SUITE_data/allocator_test.h         |  3 +-
 erts/emulator/test/alloc_SUITE_data/coalesce.c     |  2 +-
 erts/emulator/test/alloc_SUITE_data/rbtree.c       | 90 +++++++++++-----------
 3 files changed, 48 insertions(+), 47 deletions(-)

(limited to 'erts/emulator/test/alloc_SUITE_data')

diff --git a/erts/emulator/test/alloc_SUITE_data/allocator_test.h b/erts/emulator/test/alloc_SUITE_data/allocator_test.h
index c37b074f93..2d6c5f9dc7 100644
--- a/erts/emulator/test/alloc_SUITE_data/allocator_test.h
+++ b/erts/emulator/test/alloc_SUITE_data/allocator_test.h
@@ -102,7 +102,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))
diff --git a/erts/emulator/test/alloc_SUITE_data/coalesce.c b/erts/emulator/test/alloc_SUITE_data/coalesce.c
index 36710bf7b5..9da49a0d14 100644
--- a/erts/emulator/test/alloc_SUITE_data/coalesce.c
+++ b/erts/emulator/test/alloc_SUITE_data/coalesce.c
@@ -267,7 +267,7 @@ void
 testcase_run(TestCaseState_t *tcs)
 {
     char *argv_org[] = {"-tsmbcs511","-tmmbcs511", "-tsbct512", "-trmbcmt100", "-tas", NULL, NULL};
-    char *alg[] = {"af", "gf", "bf", "aobf", "aoff", "aoffcaobf", NULL};
+    char *alg[] = {"af", "gf", "bf", "aobf", "aoff", "aoffcbf", "aoffcaobf", NULL};
     int i;
 
     for (i = 0; alg[i]; i++) {
diff --git a/erts/emulator/test/alloc_SUITE_data/rbtree.c b/erts/emulator/test/alloc_SUITE_data/rbtree.c
index 702f075304..49df2f0245 100644
--- a/erts/emulator/test/alloc_SUITE_data/rbtree.c
+++ b/erts/emulator/test/alloc_SUITE_data/rbtree.c
@@ -85,23 +85,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 +189,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 +210,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 +248,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;
 		}
-
 	    }
 	}
 
@@ -310,7 +285,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,6 +463,7 @@ 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;
 
@@ -511,6 +487,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 +506,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 +524,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 +535,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 +544,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);
-- 
cgit v1.2.3


From 738c34d4bb8f1a3811acd00af8c6c12107f8315b Mon Sep 17 00:00:00 2001
From: Bruce Yinhe <bruce@erlang.org>
Date: Thu, 18 Jun 2015 11:31:02 +0200
Subject: Change license text to APLv2

---
 erts/emulator/test/alloc_SUITE_data/Makefile.src    | 21 +++++++++++----------
 .../emulator/test/alloc_SUITE_data/allocator_test.h | 21 +++++++++++----------
 erts/emulator/test/alloc_SUITE_data/basic.c         | 21 +++++++++++----------
 erts/emulator/test/alloc_SUITE_data/bucket_index.c  | 21 +++++++++++----------
 erts/emulator/test/alloc_SUITE_data/bucket_mask.c   | 21 +++++++++++----------
 erts/emulator/test/alloc_SUITE_data/coalesce.c      | 21 +++++++++++----------
 erts/emulator/test/alloc_SUITE_data/cpool.c         | 19 ++++++++++---------
 .../test/alloc_SUITE_data/mseg_clear_cache.c        | 21 +++++++++++----------
 erts/emulator/test/alloc_SUITE_data/rbtree.c        | 21 +++++++++++----------
 erts/emulator/test/alloc_SUITE_data/realloc_copy.c  | 21 +++++++++++----------
 .../test/alloc_SUITE_data/testcase_driver.c         | 21 +++++++++++----------
 .../test/alloc_SUITE_data/testcase_driver.h         | 21 +++++++++++----------
 erts/emulator/test/alloc_SUITE_data/threads.c       | 21 +++++++++++----------
 13 files changed, 142 insertions(+), 129 deletions(-)

(limited to 'erts/emulator/test/alloc_SUITE_data')

diff --git a/erts/emulator/test/alloc_SUITE_data/Makefile.src b/erts/emulator/test/alloc_SUITE_data/Makefile.src
index 1d4286e671..a441fe946b 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
diff --git a/erts/emulator/test/alloc_SUITE_data/allocator_test.h b/erts/emulator/test/alloc_SUITE_data/allocator_test.h
index 2d6c5f9dc7..1d6b2f4907 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
diff --git a/erts/emulator/test/alloc_SUITE_data/basic.c b/erts/emulator/test/alloc_SUITE_data/basic.c
index 0c27665712..323a24a11f 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
diff --git a/erts/emulator/test/alloc_SUITE_data/bucket_index.c b/erts/emulator/test/alloc_SUITE_data/bucket_index.c
index 32fd16fc10..c13f229049 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
diff --git a/erts/emulator/test/alloc_SUITE_data/bucket_mask.c b/erts/emulator/test/alloc_SUITE_data/bucket_mask.c
index 34979cacf1..8d6166771e 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
diff --git a/erts/emulator/test/alloc_SUITE_data/coalesce.c b/erts/emulator/test/alloc_SUITE_data/coalesce.c
index 9da49a0d14..0a5e0c5b0e 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
diff --git a/erts/emulator/test/alloc_SUITE_data/cpool.c b/erts/emulator/test/alloc_SUITE_data/cpool.c
index 276ed7be04..75c2bc13ae 100644
--- a/erts/emulator/test/alloc_SUITE_data/cpool.c
+++ b/erts/emulator/test/alloc_SUITE_data/cpool.c
@@ -3,16 +3,17 @@
  *
  * Copyright Ericsson AB 2013. All Rights Reserved.
  *
- * The contents of this file are subject to the Erlang Public License,
- * Version 1.1, (the "License"); you may not use this file except in
- * compliance with the License. You should have received a copy of the
- * Erlang Public License along with this software. If not, it can be
- * retrieved online at http://www.erlang.org/.
+ * 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%
  */
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..9c03f3a331 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
diff --git a/erts/emulator/test/alloc_SUITE_data/rbtree.c b/erts/emulator/test/alloc_SUITE_data/rbtree.c
index 49df2f0245..8d4d5535a8 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
diff --git a/erts/emulator/test/alloc_SUITE_data/realloc_copy.c b/erts/emulator/test/alloc_SUITE_data/realloc_copy.c
index 12454c75e4..e405f06225 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
diff --git a/erts/emulator/test/alloc_SUITE_data/testcase_driver.c b/erts/emulator/test/alloc_SUITE_data/testcase_driver.c
index 5c4b11454f..bc674c56b7 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
diff --git a/erts/emulator/test/alloc_SUITE_data/testcase_driver.h b/erts/emulator/test/alloc_SUITE_data/testcase_driver.h
index 66d567cb44..5d17eaec64 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
diff --git a/erts/emulator/test/alloc_SUITE_data/threads.c b/erts/emulator/test/alloc_SUITE_data/threads.c
index 1247e5d7dd..edad24ee6b 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
-- 
cgit v1.2.3


From b72ad981e96fcc14c245ef2bd10c5c98c6a239f6 Mon Sep 17 00:00:00 2001
From: Sverker Eriksson <sverker@erlang.org>
Date: Fri, 5 Dec 2014 15:13:07 +0100
Subject: erts: Add TEST allocator

---
 erts/emulator/test/alloc_SUITE_data/allocator_test.h | 2 ++
 1 file changed, 2 insertions(+)

(limited to 'erts/emulator/test/alloc_SUITE_data')

diff --git a/erts/emulator/test/alloc_SUITE_data/allocator_test.h b/erts/emulator/test/alloc_SUITE_data/allocator_test.h
index 1d6b2f4907..a7f12c6ca8 100644
--- a/erts/emulator/test/alloc_SUITE_data/allocator_test.h
+++ b/erts/emulator/test/alloc_SUITE_data/allocator_test.h
@@ -142,5 +142,7 @@ 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)))
 
 #endif
-- 
cgit v1.2.3


From 38ddf72b48377bd6b2fb8c4b6981360ae7d44d79 Mon Sep 17 00:00:00 2001
From: Sverker Eriksson <sverker@erlang.org>
Date: Mon, 8 Dec 2014 15:38:04 +0100
Subject: erts: Add alloc_SUITE:migration

---
 erts/emulator/test/alloc_SUITE_data/Makefile.src   |   3 +-
 .../test/alloc_SUITE_data/allocator_test.h         |   2 +
 erts/emulator/test/alloc_SUITE_data/migration.c    | 229 +++++++++++++++++++++
 .../test/alloc_SUITE_data/testcase_driver.c        |  14 ++
 .../test/alloc_SUITE_data/testcase_driver.h        |   1 +
 5 files changed, 248 insertions(+), 1 deletion(-)
 create mode 100644 erts/emulator/test/alloc_SUITE_data/migration.c

(limited to 'erts/emulator/test/alloc_SUITE_data')

diff --git a/erts/emulator/test/alloc_SUITE_data/Makefile.src b/erts/emulator/test/alloc_SUITE_data/Makefile.src
index a441fe946b..e31de54e1b 100644
--- a/erts/emulator/test/alloc_SUITE_data/Makefile.src
+++ b/erts/emulator/test/alloc_SUITE_data/Makefile.src
@@ -25,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 a7f12c6ca8..bfd0bb3094 100644
--- a/erts/emulator/test/alloc_SUITE_data/allocator_test.h
+++ b/erts/emulator/test/alloc_SUITE_data/allocator_test.h
@@ -85,6 +85,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)))
@@ -144,5 +145,6 @@ typedef void* erts_cond;
 #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)))
 
 #endif
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..dd58a0d3dd
--- /dev/null
+++ b/erts/emulator/test/alloc_SUITE_data/migration.c
@@ -0,0 +1,229 @@
+/*
+ * %CopyrightBegin%
+ *
+ * Copyright Ericsson AB 2014. 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 <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";
+}
+
+void
+testcase_cleanup(TestCaseState_t *tcs)
+{
+}
+
+#define MAX_BLOCK_PER_THR 100
+#define MAX_ROUNDS 10
+
+typedef struct MyBlock_ {
+    struct MyBlock_* next;
+    struct MyBlock_** prevp;
+} MyBlock;
+
+typedef struct {
+    MyBlock* blockv[MAX_BLOCK_PER_THR];
+    enum { GROWING, SHRINKING, CLEANUP, DONE } phase;
+    int ix;
+    int round;
+} MigrationState;
+
+typedef struct {
+    ErlDrvMutex* mtx;
+    int nblocks;
+    MyBlock* first;
+} 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 = erl_drv_mutex_create("alloc_SUITE.migration");
+    mci->nblocks = 0;
+    mci->first = 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);
+    erl_drv_mutex_destroy(mci->mtx);
+
+    if (orig_destroying_mbc_fn)
+	orig_destroying_mbc_fn(allctr, carrier);
+}
+
+
+static void setup(TestCaseState_t* tcs)
+{
+    void* creating_mbc_arg = (void*)my_creating_mbc;
+    void* destroying_mbc_arg = (void*)my_destroying_mbc;
+    crr_info_offset = SET_TEST_MBC_USER_HEADER(sizeof(MyCrrInfo),
+					       &creating_mbc_arg,
+					       &destroying_mbc_arg);
+    ASSERT(tcs, crr_info_offset >= 0);
+    orig_create_mbc_fn = creating_mbc_arg;
+    orig_destroying_mbc_fn = destroying_mbc_arg;
+}
+
+static void add_block(MyBlock* p)
+{
+    MyCrrInfo* mci = (MyCrrInfo*)((char*)BLK_TO_MBC(UMEM2BLK_TEST(p)) + crr_info_offset);
+
+    erl_drv_mutex_lock(mci->mtx);
+    mci->nblocks++;
+    p->next = mci->first;
+    p->prevp = &mci->first;
+    mci->first = p;
+    if (p->next)
+	p->next->prevp = &p->next;
+    erl_drv_mutex_unlock(mci->mtx);
+}
+
+static void remove_block(MyBlock* p)
+{
+    MyCrrInfo* mci = (MyCrrInfo*)((char*)BLK_TO_MBC(UMEM2BLK_TEST(p)) + crr_info_offset);
+
+    erl_drv_mutex_lock(mci->mtx);
+    mci->nblocks--;
+    if (p->next)
+	p->next->prevp = p->prevp;
+    *p->prevp = p->next;
+    erl_drv_mutex_unlock(mci->mtx);
+}
+
+void
+testcase_run(TestCaseState_t *tcs)
+{
+    MigrationState* state = (MigrationState*) tcs->extra;
+
+    if (tcs->command_len == 4
+	&& memcmp(tcs->command, "init", tcs->command_len) == 0) {
+	setup(tcs);
+	return;
+    }
+
+    if (!tcs->extra) {
+	if (!IS_SMP_ENABLED)
+	    testcase_skipped(tcs, "No SMP support");
+
+	tcs->extra = driver_alloc(sizeof(MigrationState));
+	state = (MigrationState*) tcs->extra;
+	memset(state->blockv, 0, sizeof(state->blockv));
+	state->phase = GROWING;
+	state->ix = 0;
+	state->round = 0;
+    }
+
+    switch (state->phase) {
+    case GROWING: {
+	MyBlock* p;
+	FATAL_ASSERT(!state->blockv[state->ix]);
+	p = ALLOC_TEST((1 << 18) / 5);
+	FATAL_ASSERT(p);
+	add_block(p);
+	state->blockv[state->ix] = p;
+	do {
+	    if (++state->ix >= MAX_BLOCK_PER_THR) {
+		state->phase = SHRINKING;
+		state->ix = 0;
+		break;
+	    }
+	} while (state->blockv[state->ix] != NULL);
+	break;
+    }
+    case SHRINKING:
+	FATAL_ASSERT(state->blockv[state->ix]);
+	remove_block(state->blockv[state->ix]);
+	FREE_TEST(state->blockv[state->ix]);
+	state->blockv[state->ix] = NULL;
+
+	state->ix += 1 + ((state->ix % 3) == 0);
+	if (state->ix >= MAX_BLOCK_PER_THR) {
+	    if (++state->round >= MAX_ROUNDS) {
+		state->phase = CLEANUP;
+	    } else {
+		state->phase = GROWING;
+	    }
+	    state->ix = 0;
+	}
+	break;
+
+    case CLEANUP:
+	if (state->blockv[state->ix]) {
+	    remove_block(state->blockv[state->ix]);
+	    FREE_TEST(state->blockv[state->ix]);
+	}
+	if (++state->ix >= MAX_BLOCK_PER_THR)
+	    state->phase = DONE;
+	break;
+
+    default:
+	FATAL_ASSERT(!"Invalid phase");
+    }
+
+    if (state->phase == DONE) {
+	driver_free(tcs->extra);
+	tcs->extra = NULL;
+    }
+    else
+	testcase_continue(tcs);
+}
diff --git a/erts/emulator/test/alloc_SUITE_data/testcase_driver.c b/erts/emulator/test/alloc_SUITE_data/testcase_driver.c
index bc674c56b7..d04eb1bcb0 100644
--- a/erts/emulator/test/alloc_SUITE_data/testcase_driver.c
+++ b/erts/emulator/test/alloc_SUITE_data/testcase_driver.c
@@ -39,6 +39,7 @@
 #define TESTCASE_FAILED		0
 #define TESTCASE_SKIPPED	1
 #define TESTCASE_SUCCEEDED	2
+#define TESTCASE_CONTINUE	3
 
 typedef struct {
     TestCaseState_t visible;
@@ -129,6 +130,12 @@ testcase_drv_run(ErlDrvData drv_data, char *buf, ErlDrvSizeT len)
     }
 
     switch (itcs->result) {
+    case TESTCASE_CONTINUE:
+	msg[0] = ERL_DRV_ATOM;
+	msg[1] = driver_mk_atom("continue");
+	erl_drv_output_term(itcs->port_id, msg, 2);
+	return;
+
     case TESTCASE_SUCCEEDED:
 	result_atom = driver_mk_atom("succeeded");
 	break;
@@ -239,6 +246,13 @@ void testcase_skipped(TestCaseState_t *tcs, char *frmt, ...)
     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, ...)
 {
     InternalTestCaseState_t *itcs = (InternalTestCaseState_t *) tcs;
diff --git a/erts/emulator/test/alloc_SUITE_data/testcase_driver.h b/erts/emulator/test/alloc_SUITE_data/testcase_driver.h
index 5d17eaec64..5d439735b7 100644
--- a/erts/emulator/test/alloc_SUITE_data/testcase_driver.h
+++ b/erts/emulator/test/alloc_SUITE_data/testcase_driver.h
@@ -37,6 +37,7 @@ typedef struct {
 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);
-- 
cgit v1.2.3


From 41e0c6e584d392ed0d5fbbc51a84418c4f7abcf5 Mon Sep 17 00:00:00 2001
From: Sverker Eriksson <sverker@erlang.org>
Date: Tue, 9 Dec 2014 11:53:16 +0100
Subject: erts: Refactor alloc_SUITE to use NIFs instead of drivers

---
 .../test/alloc_SUITE_data/allocator_test.h         |  15 +-
 erts/emulator/test/alloc_SUITE_data/basic.c        |   3 +
 erts/emulator/test/alloc_SUITE_data/basic.erl      |  10 ++
 erts/emulator/test/alloc_SUITE_data/bucket_index.c |   2 +
 .../test/alloc_SUITE_data/bucket_index.erl         |  10 ++
 erts/emulator/test/alloc_SUITE_data/bucket_mask.c  |   2 +
 .../emulator/test/alloc_SUITE_data/bucket_mask.erl |  10 ++
 erts/emulator/test/alloc_SUITE_data/coalesce.c     |   3 +
 erts/emulator/test/alloc_SUITE_data/coalesce.erl   |  10 ++
 erts/emulator/test/alloc_SUITE_data/cpool.c        |   9 +-
 erts/emulator/test/alloc_SUITE_data/cpool.erl      |  10 ++
 erts/emulator/test/alloc_SUITE_data/migration.c    |  44 +++---
 erts/emulator/test/alloc_SUITE_data/migration.erl  |  10 ++
 .../test/alloc_SUITE_data/mseg_clear_cache.c       |   3 +
 .../test/alloc_SUITE_data/mseg_clear_cache.erl     |  10 ++
 erts/emulator/test/alloc_SUITE_data/rbtree.c       |   3 +
 erts/emulator/test/alloc_SUITE_data/rbtree.erl     |  10 ++
 erts/emulator/test/alloc_SUITE_data/realloc_copy.c |   2 +
 .../test/alloc_SUITE_data/realloc_copy.erl         |  10 ++
 .../test/alloc_SUITE_data/testcase_driver.c        | 171 ++++++++-------------
 .../test/alloc_SUITE_data/testcase_driver.h        |  11 +-
 erts/emulator/test/alloc_SUITE_data/threads.c      |   6 +-
 erts/emulator/test/alloc_SUITE_data/threads.erl    |  10 ++
 23 files changed, 235 insertions(+), 139 deletions(-)
 create mode 100644 erts/emulator/test/alloc_SUITE_data/basic.erl
 create mode 100644 erts/emulator/test/alloc_SUITE_data/bucket_index.erl
 create mode 100644 erts/emulator/test/alloc_SUITE_data/bucket_mask.erl
 create mode 100644 erts/emulator/test/alloc_SUITE_data/coalesce.erl
 create mode 100644 erts/emulator/test/alloc_SUITE_data/cpool.erl
 create mode 100644 erts/emulator/test/alloc_SUITE_data/migration.erl
 create mode 100644 erts/emulator/test/alloc_SUITE_data/mseg_clear_cache.erl
 create mode 100644 erts/emulator/test/alloc_SUITE_data/rbtree.erl
 create mode 100644 erts/emulator/test/alloc_SUITE_data/realloc_copy.erl
 create mode 100644 erts/emulator/test/alloc_SUITE_data/threads.erl

(limited to 'erts/emulator/test/alloc_SUITE_data')

diff --git a/erts/emulator/test/alloc_SUITE_data/allocator_test.h b/erts/emulator/test/alloc_SUITE_data/allocator_test.h
index bfd0bb3094..dd0227e725 100644
--- a/erts/emulator/test/alloc_SUITE_data/allocator_test.h
+++ b/erts/emulator/test/alloc_SUITE_data/allocator_test.h
@@ -20,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
 
diff --git a/erts/emulator/test/alloc_SUITE_data/basic.c b/erts/emulator/test/alloc_SUITE_data/basic.c
index 323a24a11f..debb3d7ebe 100644
--- a/erts/emulator/test/alloc_SUITE_data/basic.c
+++ b/erts/emulator/test/alloc_SUITE_data/basic.c
@@ -60,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 c13f229049..45cb53fbf7 100644
--- a/erts/emulator/test/alloc_SUITE_data/bucket_index.c
+++ b/erts/emulator/test/alloc_SUITE_data/bucket_index.c
@@ -113,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 8d6166771e..d474c80343 100644
--- a/erts/emulator/test/alloc_SUITE_data/bucket_mask.c
+++ b/erts/emulator/test/alloc_SUITE_data/bucket_mask.c
@@ -183,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 0a5e0c5b0e..7791409a34 100644
--- a/erts/emulator/test/alloc_SUITE_data/coalesce.c
+++ b/erts/emulator/test/alloc_SUITE_data/coalesce.c
@@ -317,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 75c2bc13ae..73026cc758 100644
--- a/erts/emulator/test/alloc_SUITE_data/cpool.c
+++ b/erts/emulator/test/alloc_SUITE_data/cpool.c
@@ -86,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]));
 	}
@@ -129,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;
 	}
     }
@@ -156,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
index dd58a0d3dd..9f6535c834 100644
--- a/erts/emulator/test/alloc_SUITE_data/migration.c
+++ b/erts/emulator/test/alloc_SUITE_data/migration.c
@@ -60,6 +60,8 @@ testcase_name(void)
 void
 testcase_cleanup(TestCaseState_t *tcs)
 {
+    enif_free(tcs->extra);
+    tcs->extra = NULL;
 }
 
 #define MAX_BLOCK_PER_THR 100
@@ -78,7 +80,7 @@ typedef struct {
 } MigrationState;
 
 typedef struct {
-    ErlDrvMutex* mtx;
+    ErlNifMutex* mtx;
     int nblocks;
     MyBlock* first;
 } MyCrrInfo;
@@ -94,7 +96,7 @@ static void my_creating_mbc(Allctr_t *allctr, Carrier_t *carrier)
     if (orig_create_mbc_fn)
 	orig_create_mbc_fn(allctr, carrier);
 
-    mci->mtx = erl_drv_mutex_create("alloc_SUITE.migration");
+    mci->mtx = enif_mutex_create("alloc_SUITE.migration");
     mci->nblocks = 0;
     mci->first = NULL;
 }
@@ -105,49 +107,54 @@ static void my_destroying_mbc(Allctr_t *allctr, Carrier_t *carrier)
 
     FATAL_ASSERT(mci->nblocks == 0);
     FATAL_ASSERT(mci->first == NULL);
-    erl_drv_mutex_destroy(mci->mtx);
+    enif_mutex_destroy(mci->mtx);
 
     if (orig_destroying_mbc_fn)
 	orig_destroying_mbc_fn(allctr, carrier);
 }
 
-
-static void setup(TestCaseState_t* tcs)
+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);
-    ASSERT(tcs, crr_info_offset >= 0);
+    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)
 {
     MyCrrInfo* mci = (MyCrrInfo*)((char*)BLK_TO_MBC(UMEM2BLK_TEST(p)) + crr_info_offset);
 
-    erl_drv_mutex_lock(mci->mtx);
+    enif_mutex_lock(mci->mtx);
     mci->nblocks++;
     p->next = mci->first;
     p->prevp = &mci->first;
     mci->first = p;
     if (p->next)
 	p->next->prevp = &p->next;
-    erl_drv_mutex_unlock(mci->mtx);
+    enif_mutex_unlock(mci->mtx);
 }
 
 static void remove_block(MyBlock* p)
 {
     MyCrrInfo* mci = (MyCrrInfo*)((char*)BLK_TO_MBC(UMEM2BLK_TEST(p)) + crr_info_offset);
 
-    erl_drv_mutex_lock(mci->mtx);
+    enif_mutex_lock(mci->mtx);
     mci->nblocks--;
     if (p->next)
 	p->next->prevp = p->prevp;
     *p->prevp = p->next;
-    erl_drv_mutex_unlock(mci->mtx);
+    enif_mutex_unlock(mci->mtx);
 }
 
 void
@@ -155,17 +162,11 @@ testcase_run(TestCaseState_t *tcs)
 {
     MigrationState* state = (MigrationState*) tcs->extra;
 
-    if (tcs->command_len == 4
-	&& memcmp(tcs->command, "init", tcs->command_len) == 0) {
-	setup(tcs);
-	return;
-    }
-
     if (!tcs->extra) {
 	if (!IS_SMP_ENABLED)
 	    testcase_skipped(tcs, "No SMP support");
 
-	tcs->extra = driver_alloc(sizeof(MigrationState));
+	tcs->extra = enif_alloc(sizeof(MigrationState));
 	state = (MigrationState*) tcs->extra;
 	memset(state->blockv, 0, sizeof(state->blockv));
 	state->phase = GROWING;
@@ -220,10 +221,9 @@ testcase_run(TestCaseState_t *tcs)
 	FATAL_ASSERT(!"Invalid phase");
     }
 
-    if (state->phase == DONE) {
-	driver_free(tcs->extra);
-	tcs->extra = NULL;
-    }
-    else
+    if (state->phase != DONE)
 	testcase_continue(tcs);
 }
+
+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 9c03f3a331..e5df3d647f 100644
--- a/erts/emulator/test/alloc_SUITE_data/mseg_clear_cache.c
+++ b/erts/emulator/test/alloc_SUITE_data/mseg_clear_cache.c
@@ -101,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 8d4d5535a8..eb7b36984e 100644
--- a/erts/emulator/test/alloc_SUITE_data/rbtree.c
+++ b/erts/emulator/test/alloc_SUITE_data/rbtree.c
@@ -577,3 +577,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 e405f06225..c4147eb00d 100644
--- a/erts/emulator/test/alloc_SUITE_data/realloc_copy.c
+++ b/erts/emulator/test/alloc_SUITE_data/realloc_copy.c
@@ -278,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 d04eb1bcb0..83ee1b67ca 100644
--- a/erts/emulator/test/alloc_SUITE_data/testcase_driver.c
+++ b/erts/emulator/test/alloc_SUITE_data/testcase_driver.c
@@ -43,128 +43,95 @@
 
 typedef struct {
     TestCaseState_t visible;
-    ErlDrvPort port;
-    ErlDrvTermData  port_id;
+    ErlNifEnv* curr_env;
     int result;
     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[])
 {
+    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));
+
+    if (!itcs || !enif_get_int(env, argv[0], &itcs->visible.thr_nr)) {
+	enif_make_badarg(env);
     }
 
     itcs->visible.testcase_name = testcase_name();
+
     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;
+
+    if (!enif_get_resource(env, argv[0], testcase_rt, (void**)&itcs))
+	return enif_make_badarg(env);
 
-    itcs->visible.command = buf;
-    itcs->visible.command_len = len;
+    itcs->curr_env = env;
 
     if (setjmp(itcs->done_jmp_buf) == 0) {
-	testcase_run((TestCaseState_t *) itcs);
+	testcase_run(&itcs->visible);
 	itcs->result = TESTCASE_SUCCEEDED;
     }
 
     switch (itcs->result) {
     case TESTCASE_CONTINUE:
-	msg[0] = ERL_DRV_ATOM;
-	msg[1] = driver_mk_atom("continue");
-	erl_drv_output_term(itcs->port_id, msg, 2);
-	return;
-
-    case TESTCASE_SUCCEEDED:
-	result_atom = driver_mk_atom("succeeded");
-	break;
-    case TESTCASE_SKIPPED:
-	result_atom = driver_mk_atom("skipped");
-	break;
-    case TESTCASE_FAILED:
-    default:
-	result_atom = driver_mk_atom("failed");
-	break;
-    }
-
-    msg[0] = ERL_DRV_ATOM;
-    msg[1] = (ErlDrvTermData) result_atom;
-
-    msg[2] = ERL_DRV_PORT;
-    msg[3] = itcs->port_id;
+	return enif_make_atom(env, "continue");
 
-    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;
+    case TESTCASE_SUCCEEDED: result_atom = "succeeded"; break;
+    case TESTCASE_SKIPPED: result_atom = "skipped"; break;
+    case TESTCASE_FAILED: result_atom = "failed"; break;
+    }
 
-    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
@@ -179,8 +146,10 @@ 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
@@ -190,23 +159,13 @@ testcase_printf(TestCaseState_t *tcs, char *frmt, ...)
 #endif
     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[6] = ERL_DRV_STRING;
-    msg[7] = (ErlDrvTermData) itcs->comment_buf;
-    msg[8] = (ErlDrvTermData) strlen(itcs->comment_buf);
+    msg = enif_make_tuple2(msg_env, print_atom,
+		    enif_make_string(msg_env, itcs->comment_buf, ERL_NIF_LATIN1));
 
-    msg[9] = ERL_DRV_TUPLE;
-    msg[10] = (ErlDrvTermData) 4;
+    enif_send(itcs->curr_env, enif_self(itcs->curr_env, &pid),
+	      msg_env, msg);
 
-    erl_drv_output_term(itcs->port_id, msg, 11);
+    enif_free_env(msg_env);
 }
 
 
@@ -270,7 +229,7 @@ void testcase_failed(TestCaseState_t *tcs, char *frmt, ...)
     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);
@@ -282,15 +241,15 @@ void testcase_failed(TestCaseState_t *tcs, char *frmt, ...)
 
 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 5d439735b7..698ae66fac 100644
--- a/erts/emulator/test/alloc_SUITE_data/testcase_driver.h
+++ b/erts/emulator/test/alloc_SUITE_data/testcase_driver.h
@@ -20,13 +20,12 @@
 #ifndef TESTCASE_DRIVER_H__
 #define TESTCASE_DRIVER_H__
 
-#include "erl_driver.h"
+#include "erl_nif.h"
 #include <stdlib.h>
 
 typedef struct {
     char *testcase_name;
-    char *command;
-    int command_len;
+    int thr_nr;
     void *extra;
 } TestCaseState_t;
 
@@ -34,6 +33,7 @@ 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, ...);
@@ -46,8 +46,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 edad24ee6b..a8a6a23695 100644
--- a/erts/emulator/test/alloc_SUITE_data/threads.c
+++ b/erts/emulator/test/alloc_SUITE_data/threads.c
@@ -86,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);
@@ -187,7 +187,6 @@ 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;
 
@@ -446,3 +445,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).
-- 
cgit v1.2.3


From 3198ed17179f35b86f7f8ab5c0b9c165d44c1ba6 Mon Sep 17 00:00:00 2001
From: Sverker Eriksson <sverker@erlang.org>
Date: Wed, 10 Dec 2014 20:03:02 +0100
Subject: erts: Workaround for strange crash on win64 in alloc_SUITE test code

For some reason setjmp() crash when having jmp_buf heap allocated
but works when stack allocated.
---
 erts/emulator/test/alloc_SUITE_data/testcase_driver.c | 19 +++++++++++++------
 1 file changed, 13 insertions(+), 6 deletions(-)

(limited to 'erts/emulator/test/alloc_SUITE_data')

diff --git a/erts/emulator/test/alloc_SUITE_data/testcase_driver.c b/erts/emulator/test/alloc_SUITE_data/testcase_driver.c
index 83ee1b67ca..5b35f581ea 100644
--- a/erts/emulator/test/alloc_SUITE_data/testcase_driver.c
+++ b/erts/emulator/test/alloc_SUITE_data/testcase_driver.c
@@ -45,7 +45,7 @@ typedef struct {
     TestCaseState_t visible;
     ErlNifEnv* curr_env;
     int result;
-    jmp_buf done_jmp_buf;
+    jmp_buf* done_jmp_buf;
     char *comment;
     char comment_buf[COMMENT_BUF_SZ];
 } InternalTestCaseState_t;
@@ -110,13 +110,20 @@ testcase_nif_run(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
 {
     InternalTestCaseState_t *itcs;
     const char* result_atom;
+    jmp_buf the_jmp_buf;
 
     if (!enif_get_resource(env, argv[0], testcase_rt, (void**)&itcs))
 	return enif_make_badarg(env);
 
     itcs->curr_env = env;
 
-    if (setjmp(itcs->done_jmp_buf) == 0) {
+    /* 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;
     }
@@ -184,7 +191,7 @@ void testcase_succeeded(TestCaseState_t *tcs, char *frmt, ...)
     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, ...)
@@ -202,14 +209,14 @@ void testcase_skipped(TestCaseState_t *tcs, char *frmt, ...)
     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);
+    longjmp(*itcs->done_jmp_buf, 1);
 }
 
 void testcase_failed(TestCaseState_t *tcs, char *frmt, ...)
@@ -236,7 +243,7 @@ void testcase_failed(TestCaseState_t *tcs, char *frmt, ...)
 	abort();
     }
 
-    longjmp(itcs->done_jmp_buf, 1);
+    longjmp(*itcs->done_jmp_buf, 1);
 }
 
 void *testcase_alloc(size_t size)
-- 
cgit v1.2.3


From 8421d318090ca59406ef6e04a43af16e1a467d9b Mon Sep 17 00:00:00 2001
From: Sverker Eriksson <sverker@erlang.org>
Date: Mon, 12 Oct 2015 17:00:07 +0200
Subject: erts: Fix snprintf in alloc_SUITE for windows

---
 .../test/alloc_SUITE_data/testcase_driver.c        | 47 ++++++++++------------
 1 file changed, 21 insertions(+), 26 deletions(-)

(limited to 'erts/emulator/test/alloc_SUITE_data')

diff --git a/erts/emulator/test/alloc_SUITE_data/testcase_driver.c b/erts/emulator/test/alloc_SUITE_data/testcase_driver.c
index 5b35f581ea..1503fea4cb 100644
--- a/erts/emulator/test/alloc_SUITE_data/testcase_driver.c
+++ b/erts/emulator/test/alloc_SUITE_data/testcase_driver.c
@@ -25,14 +25,25 @@
 #include <string.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
 
@@ -159,11 +170,7 @@ testcase_printf(TestCaseState_t *tcs, char *frmt, ...)
     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 = enif_make_tuple2(msg_env, print_atom,
@@ -181,11 +188,7 @@ 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;
@@ -199,11 +202,7 @@ 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;
@@ -226,11 +225,7 @@ 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;
-- 
cgit v1.2.3


From d1464746f9e2c24e7bc645a4fdb543d63a8e3e87 Mon Sep 17 00:00:00 2001
From: Sverker Eriksson <sverker@erlang.org>
Date: Mon, 12 Oct 2015 17:06:27 +0200
Subject: erts: Pass free mem and build type to alloc_SUITE tests

---
 erts/emulator/test/alloc_SUITE_data/bucket_mask.c  |  2 +-
 .../test/alloc_SUITE_data/testcase_driver.c        | 30 ++++++++++++++++------
 .../test/alloc_SUITE_data/testcase_driver.h        |  3 +++
 3 files changed, 26 insertions(+), 9 deletions(-)

(limited to 'erts/emulator/test/alloc_SUITE_data')

diff --git a/erts/emulator/test/alloc_SUITE_data/bucket_mask.c b/erts/emulator/test/alloc_SUITE_data/bucket_mask.c
index d474c80343..c94c265f4e 100644
--- a/erts/emulator/test/alloc_SUITE_data/bucket_mask.c
+++ b/erts/emulator/test/alloc_SUITE_data/bucket_mask.c
@@ -52,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;
diff --git a/erts/emulator/test/alloc_SUITE_data/testcase_driver.c b/erts/emulator/test/alloc_SUITE_data/testcase_driver.c
index 1503fea4cb..7dcca544e5 100644
--- a/erts/emulator/test/alloc_SUITE_data/testcase_driver.c
+++ b/erts/emulator/test/alloc_SUITE_data/testcase_driver.c
@@ -23,6 +23,7 @@
 #include <stdarg.h>
 #include <setjmp.h>
 #include <string.h>
+#include <limits.h>
 
 #ifdef __WIN32__
 static void my_vsnprintf(char *outBuf, size_t size, const char *format, va_list ap)
@@ -54,7 +55,6 @@ static void my_snprintf(char *outBuf, size_t size, const char *format, ...)
 
 typedef struct {
     TestCaseState_t visible;
-    ErlNifEnv* curr_env;
     int result;
     jmp_buf* done_jmp_buf;
     char *comment;
@@ -86,17 +86,26 @@ int testcase_nif_init(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_info)
 
 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 *)
              enif_alloc_resource(testcase_rt, sizeof(InternalTestCaseState_t));
-
-    if (!itcs || !enif_get_int(env, argv[0], &itcs->visible.thr_nr)) {
+    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->result = TESTCASE_FAILED;
     itcs->comment = "";
@@ -126,7 +135,7 @@ testcase_nif_run(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
     if (!enif_get_resource(env, argv[0], testcase_rt, (void**)&itcs))
 	return enif_make_badarg(env);
 
-    itcs->curr_env = env;
+    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
@@ -146,6 +155,11 @@ testcase_nif_run(ErlNifEnv* env, int argc, const ERL_NIF_TERM argv[])
     case TESTCASE_SUCCEEDED: result_atom = "succeeded"; break;
     case TESTCASE_SKIPPED: result_atom = "skipped"; break;
     case TESTCASE_FAILED: result_atom = "failed"; break;
+    default:
+        result_atom = "failed";
+        my_snprintf(itcs->comment_buf, sizeof(itcs->comment_buf),
+		    "Unexpected test result code %d.", itcs->result);
+        itcs->comment = itcs->comment_buf;
     }
 
     return enif_make_tuple2(env, enif_make_atom(env, result_atom),
@@ -176,7 +190,7 @@ testcase_printf(TestCaseState_t *tcs, char *frmt, ...)
     msg = enif_make_tuple2(msg_env, print_atom,
 		    enif_make_string(msg_env, itcs->comment_buf, ERL_NIF_LATIN1));
 
-    enif_send(itcs->curr_env, enif_self(itcs->curr_env, &pid),
+    enif_send(itcs->visible.curr_env, enif_self(itcs->visible.curr_env, &pid),
 	      msg_env, msg);
 
     enif_free_env(msg_env);
diff --git a/erts/emulator/test/alloc_SUITE_data/testcase_driver.h b/erts/emulator/test/alloc_SUITE_data/testcase_driver.h
index 698ae66fac..f0ca91bd06 100644
--- a/erts/emulator/test/alloc_SUITE_data/testcase_driver.h
+++ b/erts/emulator/test/alloc_SUITE_data/testcase_driver.h
@@ -24,8 +24,11 @@
 #include <stdlib.h>
 
 typedef struct {
+    ErlNifEnv* curr_env;
     char *testcase_name;
     int thr_nr;
+    int free_mem; /* in bytes */
+    ERL_NIF_TERM build_type;  /* opt, debug, valgrind, ... */
     void *extra;
 } TestCaseState_t;
 
-- 
cgit v1.2.3


From 5c9557a814ac993a72d7b045ee374745d6dcab79 Mon Sep 17 00:00:00 2001
From: Sverker Eriksson <sverker@erlang.org>
Date: Fri, 2 Oct 2015 18:14:28 +0200
Subject: erts: Improve alloc_SUITE:migration test

In the quest to improve code coverage in cpool_fetch
---
 .../test/alloc_SUITE_data/allocator_test.h         |   1 +
 erts/emulator/test/alloc_SUITE_data/migration.c    | 190 ++++++++++++++++-----
 2 files changed, 153 insertions(+), 38 deletions(-)

(limited to 'erts/emulator/test/alloc_SUITE_data')

diff --git a/erts/emulator/test/alloc_SUITE_data/allocator_test.h b/erts/emulator/test/alloc_SUITE_data/allocator_test.h
index dd0227e725..97ee58cdad 100644
--- a/erts/emulator/test/alloc_SUITE_data/allocator_test.h
+++ b/erts/emulator/test/alloc_SUITE_data/allocator_test.h
@@ -157,5 +157,6 @@ typedef void* erts_cond;
 #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/migration.c b/erts/emulator/test/alloc_SUITE_data/migration.c
index 9f6535c834..b006360043 100644
--- a/erts/emulator/test/alloc_SUITE_data/migration.c
+++ b/erts/emulator/test/alloc_SUITE_data/migration.c
@@ -27,6 +27,7 @@
 #include <errno.h>
 #endif
 #include <stdio.h>
+#include <stdlib.h>
 #include <stdarg.h>
 #include <string.h>
 #include "testcase_driver.h"
@@ -57,15 +58,52 @@ testcase_name(void)
     return "migration";
 }
 
-void
-testcase_cleanup(TestCaseState_t *tcs)
+/* 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)
 {
-    enif_free(tcs->extra);
-    tcs->extra = NULL;
+    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));
 }
 
-#define MAX_BLOCK_PER_THR 100
-#define MAX_ROUNDS 10
+#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;
@@ -74,15 +112,23 @@ typedef struct MyBlock_ {
 
 typedef struct {
     MyBlock* blockv[MAX_BLOCK_PER_THR];
+    MyRandState rand_state;
     enum { GROWING, SHRINKING, CLEANUP, DONE } phase;
-    int ix;
+    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;
 
 
@@ -99,6 +145,7 @@ static void my_creating_mbc(Allctr_t *allctr, Carrier_t *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)
@@ -131,17 +178,28 @@ static int migration_init(ErlNifEnv* env, void** priv_data, ERL_NIF_TERM load_in
     return 0;
 }
 
-static void add_block(MyBlock* p)
+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);
-    mci->nblocks++;
+    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);
 }
 
@@ -157,6 +215,38 @@ static void remove_block(MyBlock* p)
     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)
 {
@@ -169,61 +259,85 @@ testcase_run(TestCaseState_t *tcs)
 	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->ix = 0;
+	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->ix]);
-	p = ALLOC_TEST((1 << 18) / 5);
+	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->blockv[state->ix] = p;
-	do {
-	    if (++state->ix >= MAX_BLOCK_PER_THR) {
-		state->phase = SHRINKING;
-		state->ix = 0;
-		break;
-	    }
-	} while (state->blockv[state->ix] != NULL);
+	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:
-	FATAL_ASSERT(state->blockv[state->ix]);
-	remove_block(state->blockv[state->ix]);
-	FREE_TEST(state->blockv[state->ix]);
-	state->blockv[state->ix] = NULL;
-
-	state->ix += 1 + ((state->ix % 3) == 0);
-	if (state->ix >= MAX_BLOCK_PER_THR) {
+    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);
 	    }
-	    state->ix = 0;
 	}
 	break;
-
+    }
     case CLEANUP:
-	if (state->blockv[state->ix]) {
-	    remove_block(state->blockv[state->ix]);
-	    FREE_TEST(state->blockv[state->ix]);
-	}
-	if (++state->ix >= MAX_BLOCK_PER_THR)
-	    state->phase = DONE;
+	do_cleanup(tcs, state);
 	break;
 
     default:
 	FATAL_ASSERT(!"Invalid phase");
     }
 
-    if (state->phase != DONE)
+    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);
-- 
cgit v1.2.3


From 64d1a7397c53d6cca32c49af9f833cdf6d26fc6e Mon Sep 17 00:00:00 2001
From: Sverker Eriksson <sverker@erlang.org>
Date: Wed, 4 Nov 2015 17:55:49 +0100
Subject: erts: Reduce alloc_SUITE:rbtree runtime for valgrind

---
 erts/emulator/test/alloc_SUITE_data/rbtree.c | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

(limited to 'erts/emulator/test/alloc_SUITE_data')

diff --git a/erts/emulator/test/alloc_SUITE_data/rbtree.c b/erts/emulator/test/alloc_SUITE_data/rbtree.c
index eb7b36984e..38bbbdf90c 100644
--- a/erts/emulator/test/alloc_SUITE_data/rbtree.c
+++ b/erts/emulator/test/alloc_SUITE_data/rbtree.c
@@ -20,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)
@@ -265,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;
 
 }
@@ -468,6 +469,12 @@ testcase_run(TestCaseState_t *tcs)
     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");
-- 
cgit v1.2.3


From ae116fb714d54ca40bcd897195de521b0ca39f8c Mon Sep 17 00:00:00 2001
From: Sverker Eriksson <sverker@erlang.org>
Date: Mon, 11 Jan 2016 17:20:24 +0100
Subject: erts: Workaround memset bug in test case

memset seen to fail with values larger than 255
on (armata) 32-bit ARM Debian
with EGLIBC 2.13-38+rpi2+deb7u8
and gcc 4.6.3-14+rpi1.
---
 erts/emulator/test/alloc_SUITE_data/threads.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

(limited to 'erts/emulator/test/alloc_SUITE_data')

diff --git a/erts/emulator/test/alloc_SUITE_data/threads.c b/erts/emulator/test/alloc_SUITE_data/threads.c
index edad24ee6b..f0711ee6e7 100644
--- a/erts/emulator/test/alloc_SUITE_data/threads.c
+++ b/erts/emulator/test/alloc_SUITE_data/threads.c
@@ -397,7 +397,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]);
@@ -407,7 +407,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);
-- 
cgit v1.2.3


From 66a80a7ab735a22249ffbbb7c88eccebba906194 Mon Sep 17 00:00:00 2001
From: Sverker Eriksson <sverker@erlang.org>
Date: Thu, 21 Jan 2016 19:53:59 +0100
Subject: erts: Add checks for thread safe allocation

Assert thread unsafe allocator is only created on non-smp
and only called by the main thread.

Removed test of unsafe allocator in custom thread.
---
 erts/emulator/test/alloc_SUITE_data/threads.c | 17 +----------------
 1 file changed, 1 insertion(+), 16 deletions(-)

(limited to 'erts/emulator/test/alloc_SUITE_data')

diff --git a/erts/emulator/test/alloc_SUITE_data/threads.c b/erts/emulator/test/alloc_SUITE_data/threads.c
index 2f5f841e3d..44d982b6c7 100644
--- a/erts/emulator/test/alloc_SUITE_data/threads.c
+++ b/erts/emulator/test/alloc_SUITE_data/threads.c
@@ -96,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;
@@ -155,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,9 +157,6 @@ 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);
@@ -173,7 +164,6 @@ testcase_run(TestCaseState_t *tcs)
     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));
 
@@ -190,12 +180,7 @@ testcase_run(TestCaseState_t *tcs)
 
 	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;
 	}
-- 
cgit v1.2.3


From 6664eed554974336909d3ffe03f20349cc4c38fd Mon Sep 17 00:00:00 2001
From: Henrik Nord <henrik@erlang.org>
Date: Tue, 15 Mar 2016 15:19:56 +0100
Subject: update copyright-year

---
 erts/emulator/test/alloc_SUITE_data/cpool.c     | 2 +-
 erts/emulator/test/alloc_SUITE_data/migration.c | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

(limited to 'erts/emulator/test/alloc_SUITE_data')

diff --git a/erts/emulator/test/alloc_SUITE_data/cpool.c b/erts/emulator/test/alloc_SUITE_data/cpool.c
index 73026cc758..0c41f4d747 100644
--- a/erts/emulator/test/alloc_SUITE_data/cpool.c
+++ b/erts/emulator/test/alloc_SUITE_data/cpool.c
@@ -1,7 +1,7 @@
 /*
  * %CopyrightBegin%
  *
- * Copyright Ericsson AB 2013. All Rights Reserved.
+ * Copyright Ericsson AB 2013-2016. All Rights Reserved.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
diff --git a/erts/emulator/test/alloc_SUITE_data/migration.c b/erts/emulator/test/alloc_SUITE_data/migration.c
index b006360043..b9a4de03b3 100644
--- a/erts/emulator/test/alloc_SUITE_data/migration.c
+++ b/erts/emulator/test/alloc_SUITE_data/migration.c
@@ -1,7 +1,7 @@
 /*
  * %CopyrightBegin%
  *
- * Copyright Ericsson AB 2014. All Rights Reserved.
+ * 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
-- 
cgit v1.2.3