Merge branch 'maint'

25 files changed, 1333 insertions, 10 deletions

diff --git a/erts/doc/src/Makefile b/erts/doc/src/Makefile
index fccdd744f3..40f74b78ff 100644
--- a/erts/doc/src/Makefile
+++ b/erts/doc/src/Makefile
@@ -53,19 +53,16 @@ XML_REF3_EFILES = \
 	erl_tracer.xml \
 	init.xml \
 	persistent_term.xml \
+	atomics.xml \
+	counters.xml \
 	zlib.xml
 
 XML_REF3_FILES = \
+	$(XML_REF3_EFILES) \
 	driver_entry.xml \
 	erl_nif.xml \
-	erl_tracer.xml \
 	erl_driver.xml \
-	erl_prim_loader.xml \
-	erlang.xml \
-	erts_alloc.xml  \
-	init.xml \
-	persistent_term.xml \
-	zlib.xml
+	erts_alloc.xml
 
 XML_PART_FILES = \
 	part.xml
diff --git a/erts/doc/src/atomics.xml b/erts/doc/src/atomics.xml
new file mode 100644
index 0000000000..3fca92fb97
--- /dev/null
+++ b/erts/doc/src/atomics.xml
@@ -0,0 +1,183 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!DOCTYPE erlref SYSTEM "erlref.dtd">
+
+<erlref>
+  <header>
+    <copyright>
+      <year>2018</year>
+      <holder>Ericsson AB. All Rights Reserved.</holder>
+    </copyright>
+    <legalnotice>
+      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.
+    </legalnotice>
+
+    <title>atomics</title>
+  </header>
+  <module>atomics</module>
+  <modulesummary>Atomic Functions</modulesummary>
+  <description>
+    <p>This module provides a set of functions to do atomic operations towards
+    mutable atomic variables. The implementation utilizes only
+    atomic hardware instructions without any software level locking, which makes
+    it very efficient for concurrent access. The atomics are organized into
+    arrays with the follwing semantics:</p>
+    <list type="bulleted">
+      <item>
+	<p>Atomics are 64 bit integers.</p>
+      </item>
+      <item>
+	<p>Atomics can be represented as either signed or unsigned.</p>
+      </item>
+      <item>
+	<p>Atomics wrap around at overflow and underflow operations.</p>
+      </item>
+      <item>
+	<p>All operations guarantee atomicity. No intermediate results can be
+	seen. The result of one mutation can only be the input to one
+	following mutation.</p>
+      </item>
+      <item>
+	<p>All atomic operations are mutually ordered. If atomic B is updated
+	<em>after</em> atomic A, then that is how it will appear to any
+	concurrent readers. No one can read the new value of B and then read the
+	old value of A.</p>
+      </item>
+      <item>
+	<p>Indexes into atomic arrays are one-based. An atomic array of
+	arity N contains N atomics with index from 1 to N.</p>
+      </item>
+    </list>
+  </description>
+
+  <datatypes>
+    <datatype>
+      <name name="atomics_ref"/>
+      <desc><p>Identifies an atomic array returned from
+        <seealso marker="#new/2"><c>new/2</c></seealso>.</p>
+      </desc>
+    </datatype>
+  </datatypes>
+
+  <funcs>
+    <func>
+      <name name="new" arity="2"/>
+      <fsummary>Create atomic array</fsummary>
+      <desc>
+        <p>Create a new atomic array of <c><anno>Arity</anno></c> atomics.</p>
+	<p>Argument <c><anno>Opts</anno></c> is a list of the following possible
+	options:</p>
+	<taglist>
+	  <tag><c>{signed, boolean()}</c></tag>
+	  <item><p>Indicate if the elements of the array will be treated
+	  as signed or unsigned integers. Default is <c>true</c> (signed).</p>
+	  <p>The integer interval for signed atomics are from <c>-(1 bsl 63)</c>
+	  to <c>(1 bsl 63)-1</c> and for unsigned atomics from <c>0</c> to <c>(1
+	  bsl 64)-1</c>.</p>
+	  </item>
+	</taglist>
+      </desc>
+    </func>
+
+    <func>
+      <name name="put" arity="3"/>
+      <fsummary>Set atomic value</fsummary>
+      <desc>
+        <p>Set atomic to <c><anno>Value</anno></c>.</p>
+      </desc>
+    </func>
+
+    <func>
+      <name name="get" arity="2"/>
+      <fsummary>Read atomic value</fsummary>
+      <desc>
+        <p>Read atomic value.</p>
+      </desc>
+    </func>
+
+    <func>
+      <name name="add" arity="3"/>
+      <fsummary>Add to atomic</fsummary>
+      <desc>
+        <p>Add <c><anno>Incr</anno></c> to atomic.</p>
+      </desc>
+    </func>
+
+    <func>
+      <name name="add_get" arity="3"/>
+      <fsummary>Atomic add and get</fsummary>
+      <desc>
+        <p>Atomic addition and return of the result.</p>
+      </desc>
+    </func>
+
+    <func>
+      <name name="sub" arity="3"/>
+      <fsummary>Subtract from atomic</fsummary>
+      <desc>
+        <p>Subtract <c><anno>Decr</anno></c> from atomic.</p>
+      </desc>
+    </func>
+
+    <func>
+      <name name="sub_get" arity="3"/>
+      <fsummary>Atomic sub and get</fsummary>
+      <desc>
+        <p>Atomic subtraction and return of the result.</p>
+      </desc>
+    </func>
+
+    <func>
+      <name name="exchange" arity="3"/>
+      <fsummary>Atomic exchange.</fsummary>
+      <desc>
+        <p>Atomically replaces the value of the atomic with
+	<c><anno>Desired</anno></c> and returns the value it held
+	previously.</p>
+      </desc>
+    </func>
+    
+    <func>
+    <name name="compare_exchange" arity="4"/>
+       <fsummary>Atomic compare and exchange.</fsummary>
+       <desc>
+         <p>Atomically compares the atomic with <c><anno>Expected</anno></c>,
+ 	and if those are equal, set atomic to <c><anno>Desired</anno></c>.
+ 	Returns <c>ok</c> if <c><anno>Desired</anno></c> was written. Returns
+ 	the actual atomic value if not equal to <c><anno>Expected</anno></c>.</p>
+       </desc>
+    </func>
+    
+    <func>
+      <name name="info" arity="1"/>
+      <fsummary>Get information about atomic array.</fsummary>
+      <desc>
+        <p>Return information about an atomic array in a map. The map
+	has the following keys:</p>
+	<taglist>
+	  <tag><c>size</c></tag>
+	  <item><p>The number of atomics in the array.</p></item>
+	  <tag><c>max</c></tag>
+	  <item><p>The highest possible value an atomic in this array can
+	  hold.</p></item>
+	  <tag><c>min</c></tag>
+	  <item><p>The lowest possible value an atomic in this array can
+	  hold.</p></item>
+	  <tag><c>memory</c></tag>
+	  <item><p>Approximate memory consumption for the array in
+	  bytes.</p></item>
+	</taglist>
+      </desc>
+    </func>
+
+ </funcs>
+</erlref>
diff --git a/erts/doc/src/counters.xml b/erts/doc/src/counters.xml
new file mode 100644
index 0000000000..85eedfdadc
--- /dev/null
+++ b/erts/doc/src/counters.xml
@@ -0,0 +1,142 @@
+<?xml version="1.0" encoding="utf-8" ?>
+<!DOCTYPE erlref SYSTEM "erlref.dtd">
+
+<erlref>
+  <header>
+    <copyright>
+      <year>2018</year>
+      <holder>Ericsson AB. All Rights Reserved.</holder>
+    </copyright>
+    <legalnotice>
+      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.
+    </legalnotice>
+
+    <title>counters</title>
+  </header>
+  <module>counters</module>
+  <modulesummary>Counter Functions</modulesummary>
+  <description>
+    <p>This module provides a set of functions to do operations towards
+    shared mutable counter variables. The implementation does not utilize any
+    software level locking, which makes it very efficient for concurrent
+    access. The counters are organized into arrays with the follwing
+    semantics:</p>
+    <list type="bulleted">
+      <item>
+	<p>Counters are 64 bit signed integers.</p>
+      </item>
+      <item>
+	<p>Counters wrap around at overflow and underflow operations.</p>
+      </item>
+      <item><p>Counters are initialized to zero and can then only be written to
+        by adding or subtracting.</p>
+      </item>
+      <item>
+	<p>Write operations guarantee atomicity. No intermediate results can be
+	seen from a single write operation.</p>
+      </item>
+      <item>
+	<p>Two types of counter arrays can be created with options <c>atomics</c> or
+	<c>write_concurrency</c>. The <c>atomics</c> counters have good allround
+	performance with nice consistent semantics while
+	<c>write_concurrency</c> counters offers even better concurrent
+	write performance at the expense of some potential read
+	inconsistencies. See <seealso marker="#new/2"><c>new/2</c></seealso>.</p>
+      </item>
+      <item>
+	<p>Indexes into counter arrays are one-based. A counter array of
+	size N contains N counters with index from 1 to N.</p>
+      </item>
+    </list>
+  </description>
+
+  <datatypes>
+    <datatype>
+      <name name="counters_ref"/>
+      <desc><p>Identifies a counter array returned from
+        <seealso marker="#new/2"><c>new/2</c></seealso>.</p>
+      </desc>
+    </datatype>
+  </datatypes>
+
+  <funcs>
+    <func>
+      <name name="new" arity="2"/>
+      <fsummary>Create counter array</fsummary>
+      <desc>
+        <p>Create a new counter array of <c><anno>Size</anno></c> counters.</p>
+	<p>Argument <c><anno>Opts</anno></c> is a list of the following possible
+	options:</p>
+	<taglist>
+	  <tag><c>atomics</c> (Default)</tag>
+	  <item><p>Counters will be sequentially consistent. If write
+	  operation A is done sequencially before write operation B, then a concurrent reader
+	  may see none of them, only A, or both A and B. It cannot see only B.</p>
+	  </item>
+	  <tag><c>write_concurrency</c></tag>
+	  <item><p>This is an optimization to achieve very efficient concurrent
+	  write operations at the expense of potential read inconsistency and memory
+	  consumption per counter.</p>
+	  <p>Read operations may see sequentially inconsistent results with
+	  regard to concurrent write operations. Even if write operation A is done
+	  sequencially before write operation B, a concurrent reader may see any
+	  combination of A and B, including only B. A read operation is only
+	  guaranteed to see all writes done sequentially before the read. No writes
+	  are ever lost, but will eventually all be seen.</p>
+	  </item>
+	</taglist>
+      </desc>
+    </func>
+
+    <func>
+      <name name="get" arity="2"/>
+      <fsummary>Read counter value</fsummary>
+      <desc>
+        <p>Read counter value.</p>
+      </desc>
+    </func>
+
+    <func>
+      <name name="add" arity="3"/>
+      <fsummary>Add to counter</fsummary>
+      <desc>
+        <p>Add <c><anno>Incr</anno></c> to counter.</p>
+      </desc>
+    </func>
+
+    <func>
+      <name name="sub" arity="3"/>
+      <fsummary>Subtract from counter</fsummary>
+      <desc>
+        <p>Subtract <c><anno>Decr</anno></c> from counter.</p>
+      </desc>
+    </func>
+
+    <func>
+      <name name="info" arity="1"/>
+      <fsummary>Get information about counter array.</fsummary>
+      <desc>
+        <p>Return information about a counter array in a map. The map
+	has the following keys (at least):</p>
+	<taglist>
+	  <tag><c>size</c></tag>
+	  <item><p>The number of counters in the array.</p></item>
+	  <tag><c>memory</c></tag>
+	  <item><p>Approximate memory consumption for the array in
+	  bytes.</p></item>
+	</taglist>
+      </desc>
+    </func>
+
+ </funcs>
+</erlref>
diff --git a/erts/doc/src/ref_man.xml b/erts/doc/src/ref_man.xml
index ff64aa86b8..a78aaa449e 100644
--- a/erts/doc/src/ref_man.xml
+++ b/erts/doc/src/ref_man.xml
@@ -50,5 +50,7 @@
   <xi:include href="erts_alloc.xml"/>
   <xi:include href="erl_nif.xml"/>
   <xi:include href="erl_tracer.xml"/>
+  <xi:include href="atomics.xml"/>
+  <xi:include href="counters.xml"/>
 </application>
 
diff --git a/erts/doc/src/specs.xml b/erts/doc/src/specs.xml
index 1ab6cdc19e..0b943e6295 100644
--- a/erts/doc/src/specs.xml
+++ b/erts/doc/src/specs.xml
@@ -6,4 +6,6 @@
   <xi:include href="../specs/specs_init.xml"/>
   <xi:include href="../specs/specs_persistent_term.xml"/>
   <xi:include href="../specs/specs_zlib.xml"/>
+  <xi:include href="../specs/specs_atomics.xml"/>
+  <xi:include href="../specs/specs_counters.xml"/>
 </specs>
diff --git a/erts/emulator/Makefile.in b/erts/emulator/Makefile.in
index 57c562ec8c..b74f8371f5 100644
--- a/erts/emulator/Makefile.in
+++ b/erts/emulator/Makefile.in
@@ -648,6 +648,8 @@ PRELOAD_BEAM =	$(ERL_TOP)/erts/preloaded/ebin/erts_code_purger.beam \
 		$(ERL_TOP)/erts/preloaded/ebin/erl_tracer.beam \
 		$(ERL_TOP)/erts/preloaded/ebin/erts_literal_area_collector.beam \
 		$(ERL_TOP)/erts/preloaded/ebin/erts_dirty_process_signal_handler.beam \
+		$(ERL_TOP)/erts/preloaded/ebin/atomics.beam \
+		$(ERL_TOP)/erts/preloaded/ebin/counters.beam \
 		$(ERL_TOP)/erts/preloaded/ebin/persistent_term.beam
 
 ifeq ($(TARGET),win32)
@@ -841,6 +843,7 @@ RUN_OBJS += \
 	$(OBJDIR)/erl_bif_info.o	$(OBJDIR)/erl_bif_op.o \
 	$(OBJDIR)/erl_bif_os.o		$(OBJDIR)/erl_bif_lists.o \
 	$(OBJDIR)/erl_bif_persistent.o \
+	$(OBJDIR)/erl_bif_atomics.o    	$(OBJDIR)/erl_bif_counters.o \
 	$(OBJDIR)/erl_bif_trace.o	$(OBJDIR)/erl_bif_unique.o \
 	$(OBJDIR)/erl_bif_wrap.o	$(OBJDIR)/erl_nfunc_sched.o \
 	$(OBJDIR)/erl_guard_bifs.o 	$(OBJDIR)/erl_dirty_bif_wrap.o \
diff --git a/erts/emulator/beam/atom.names b/erts/emulator/beam/atom.names
index 0167286bbf..3f7aa0983c 100644
--- a/erts/emulator/beam/atom.names
+++ b/erts/emulator/beam/atom.names
@@ -396,6 +396,7 @@ atom microsecond
 atom microstate_accounting
 atom milli_seconds
 atom millisecond
+atom min
 atom min_heap_size
 atom min_bin_vheap_size
 atom minor
diff --git a/erts/emulator/beam/bif.tab b/erts/emulator/beam/bif.tab
index 9a11e6a455..6015fc0691 100644
--- a/erts/emulator/beam/bif.tab
+++ b/erts/emulator/beam/bif.tab
@@ -709,3 +709,17 @@ bif persistent_term:get/0
 bif persistent_term:erase/1
 bif persistent_term:info/0
 bif erts_internal:erase_persistent_terms/0
+
+bif erts_internal:atomics_new/2
+bif atomics:get/2
+bif atomics:put/3
+bif atomics:add/3
+bif atomics:add_get/3
+bif atomics:exchange/3
+bif atomics:compare_exchange/4
+bif atomics:info/1
+
+bif erts_internal:counters_new/1
+bif erts_internal:counters_get/2
+bif erts_internal:counters_add/3
+bif erts_internal:counters_info/1
diff --git a/erts/emulator/beam/erl_alloc.types b/erts/emulator/beam/erl_alloc.types
index 02a9581c28..08dcc5ea9a 100644
--- a/erts/emulator/beam/erl_alloc.types
+++ b/erts/emulator/beam/erl_alloc.types
@@ -338,6 +338,8 @@ type	GC_INFO_REQ	SHORT_LIVED	SYSTEM		gc_info_request
 type	PORT_DATA_HEAP	STANDARD	SYSTEM		port_data_heap
 type    MSACC           DRIVER          SYSTEM          microstate_accounting
 type	SYS_CHECK_REQ	SHORT_LIVED	SYSTEM		system_check_request
+type	ATOMICS		STANDARD	SYSTEM		erl_bif_atomics
+type	COUNTERS	STANDARD	SYSTEM		erl_bif_counters
 
 #
 # Types used by system specific code
diff --git a/erts/emulator/beam/erl_bif_atomics.c b/erts/emulator/beam/erl_bif_atomics.c
new file mode 100644
index 0000000000..092dbb3bd3
--- /dev/null
+++ b/erts/emulator/beam/erl_bif_atomics.c
@@ -0,0 +1,256 @@
+/*
+ * %CopyrightBegin%
+ *
+ * Copyright Ericsson AB 2018. 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.
+ * 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.
+ *
+ * %CopyrightEnd%
+ */
+
+/*
+ * Purpose:  High performance atomics.
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
+
+#include <stddef.h> /* offsetof */
+
+#include "sys.h"
+#include "export.h"
+#include "bif.h"
+#include "erl_threads.h"
+#include "big.h"
+#include "erl_binary.h"
+#include "erl_bif_unique.h"
+#include "erl_map.h"
+
+typedef struct
+{
+    int is_signed;
+    UWord vlen;
+    erts_atomic64_t v[1];
+}AtomicsRef;
+
+static int atomics_destructor(Binary *unused)
+{
+    return 1;
+}
+
+#define OPT_SIGNED (1 << 0)
+
+BIF_RETTYPE erts_internal_atomics_new_2(BIF_ALIST_2)
+{
+    AtomicsRef* p;
+    Binary* mbin;
+    UWord i, cnt, opts;
+    Uint bytes;
+    Eterm* hp;
+
+    if (!term_to_UWord(BIF_ARG_1, &cnt)
+        || cnt == 0
+        || !term_to_UWord(BIF_ARG_2, &opts)) {
+
+        BIF_ERROR(BIF_P, BADARG);
+    }
+
+    if (cnt > (ERTS_UWORD_MAX / sizeof(p->v[0])))
+        BIF_ERROR(BIF_P, SYSTEM_LIMIT);
+
+    bytes = offsetof(AtomicsRef, v) + cnt*sizeof(p->v[0]);
+    mbin = erts_create_magic_binary_x(bytes,
+                                      atomics_destructor,
+                                      ERTS_ALC_T_ATOMICS,
+                                      0);
+    p = ERTS_MAGIC_BIN_DATA(mbin);
+    p->is_signed = opts & OPT_SIGNED;
+    p->vlen = cnt;
+    for (i=0; i < cnt; i++)
+        erts_atomic64_init_nob(&p->v[i], 0);
+    hp = HAlloc(BIF_P, ERTS_MAGIC_REF_THING_SIZE);
+    return erts_mk_magic_ref(&hp, &MSO(BIF_P), mbin);
+}
+
+static ERTS_INLINE int get_ref(Eterm ref, AtomicsRef** pp)
+{
+    Binary* mbin;
+    if (!is_internal_magic_ref(ref))
+        return 0;
+
+    mbin = erts_magic_ref2bin(ref);
+    if (ERTS_MAGIC_BIN_DESTRUCTOR(mbin) != atomics_destructor)
+        return 0;
+    *pp = ERTS_MAGIC_BIN_DATA(mbin);
+    return 1;
+}
+
+static ERTS_INLINE int get_ref_ix(Eterm ref, Eterm ix,
+                                  AtomicsRef** pp, UWord* ixp)
+{
+    return (get_ref(ref, pp)
+            && term_to_UWord(ix, ixp)
+            && --(*ixp) < (*pp)->vlen);
+}
+
+static ERTS_INLINE int get_value(AtomicsRef* p, Eterm term, erts_aint64_t *valp)
+{
+    return (p->is_signed ?
+            term_to_Sint64(term, (Sint64*)valp) :
+            term_to_Uint64(term, (Uint64*)valp));
+}
+
+static ERTS_INLINE int get_incr(AtomicsRef* p, Eterm term, erts_aint64_t *valp)
+{
+    return (term_to_Sint64(term, (Sint64*)valp)
+            || term_to_Uint64(term, (Uint64*)valp));
+}
+
+static ERTS_INLINE Eterm bld_atomic(Process* proc, AtomicsRef* p,
+                                    erts_aint64_t val)
+{
+    if (p->is_signed) {
+        if (IS_SSMALL(val))
+            return make_small((Sint) val);
+        else {
+            Uint hsz = ERTS_SINT64_HEAP_SIZE(val);
+            Eterm* hp = HAlloc(proc, hsz);
+            return erts_sint64_to_big(val, &hp);
+        }
+    }
+    else {
+        if ((Uint64)val <= MAX_SMALL)
+            return make_small((Sint) val);
+        else {
+            Uint hsz = ERTS_UINT64_HEAP_SIZE(val);
+            Eterm* hp = HAlloc(proc, hsz);
+            return erts_uint64_to_big(val, &hp);
+        }
+    }
+}
+
+BIF_RETTYPE atomics_put_3(BIF_ALIST_3)
+{
+    AtomicsRef* p;
+    UWord ix;
+    erts_aint64_t val;
+
+    if (!get_ref_ix(BIF_ARG_1, BIF_ARG_2, &p, &ix)
+        || !get_value(p, BIF_ARG_3, &val)) {
+        BIF_ERROR(BIF_P, BADARG);
+    }
+    erts_atomic64_set_mb(&p->v[ix], val);
+    return am_ok;
+}
+
+BIF_RETTYPE atomics_get_2(BIF_ALIST_2)
+{
+    AtomicsRef* p;
+    UWord ix;
+
+    if (!get_ref_ix(BIF_ARG_1, BIF_ARG_2, &p, &ix)) {
+        BIF_ERROR(BIF_P, BADARG);
+    }
+    return bld_atomic(BIF_P, p, erts_atomic64_read_mb(&p->v[ix]));
+}
+
+BIF_RETTYPE atomics_add_3(BIF_ALIST_3)
+{
+    AtomicsRef* p;
+    UWord ix;
+    erts_aint64_t incr;
+
+    if (!get_ref_ix(BIF_ARG_1, BIF_ARG_2, &p, &ix)
+        || !get_incr(p, BIF_ARG_3, &incr)) {
+        BIF_ERROR(BIF_P, BADARG);
+    }
+    erts_atomic64_add_mb(&p->v[ix], incr);
+    return am_ok;
+}
+
+BIF_RETTYPE atomics_add_get_3(BIF_ALIST_3)
+{
+    AtomicsRef* p;
+    UWord ix;
+    erts_aint64_t incr;
+
+    if (!get_ref_ix(BIF_ARG_1, BIF_ARG_2, &p, &ix)
+        || !get_incr(p, BIF_ARG_3, &incr)) {
+        BIF_ERROR(BIF_P, BADARG);
+    }
+    return bld_atomic(BIF_P, p, erts_atomic64_add_read_mb(&p->v[ix], incr));
+}
+
+BIF_RETTYPE atomics_exchange_3(BIF_ALIST_3)
+{
+    AtomicsRef* p;
+    UWord ix;
+    erts_aint64_t desired, was;
+
+    if (!get_ref_ix(BIF_ARG_1, BIF_ARG_2, &p, &ix)
+        || !get_value(p, BIF_ARG_3, &desired)) {
+        BIF_ERROR(BIF_P, BADARG);
+    }
+    was = erts_atomic64_xchg_mb(&p->v[ix], desired);
+    return bld_atomic(BIF_P, p, was);
+}
+
+BIF_RETTYPE atomics_compare_exchange_4(BIF_ALIST_4)
+{
+    AtomicsRef* p;
+    UWord ix;
+    erts_aint64_t expected, desired, was;
+
+    if (!get_ref_ix(BIF_ARG_1, BIF_ARG_2, &p, &ix)
+        || !get_value(p, BIF_ARG_3, &expected)
+        || !get_value(p, BIF_ARG_4, &desired)) {
+        BIF_ERROR(BIF_P, BADARG);
+    }
+    was = erts_atomic64_cmpxchg_mb(&p->v[ix], desired, expected);
+    return was == expected ? am_ok : bld_atomic(BIF_P, p, was);
+}
+
+BIF_RETTYPE atomics_info_1(BIF_ALIST_1)
+{
+    AtomicsRef* p;
+    Uint hsz = MAP4_SZ;
+    Eterm *hp;
+    Uint64 max;
+    Sint64 min;
+    UWord memory;
+    Eterm max_val, min_val, sz_val, mem_val;
+
+    if (!get_ref(BIF_ARG_1, &p))
+        BIF_ERROR(BIF_P, BADARG);
+
+    max = p->is_signed ? ERTS_SINT64_MAX : ERTS_UINT64_MAX;
+    min = p->is_signed ? ERTS_SINT64_MIN : 0;
+    memory = erts_magic_ref2bin(BIF_ARG_1)->orig_size;
+
+    erts_bld_uint64(NULL, &hsz, max);
+    erts_bld_sint64(NULL, &hsz, min);
+    erts_bld_uword(NULL, &hsz, p->vlen);
+    erts_bld_uword(NULL, &hsz, memory);
+
+    hp = HAlloc(BIF_P, hsz);
+    max_val = erts_bld_uint64(&hp, NULL, max);
+    min_val = erts_bld_sint64(&hp, NULL, min);
+    sz_val  = erts_bld_uword(&hp, NULL, p->vlen);
+    mem_val = erts_bld_uword(&hp, NULL, memory);
+
+    return MAP4(hp, am_max, max_val,
+                am_memory, mem_val,
+                am_min, min_val,
+                am_size, sz_val);
+}
diff --git a/erts/emulator/beam/erl_bif_counters.c b/erts/emulator/beam/erl_bif_counters.c
new file mode 100644
index 0000000000..a46b462225
--- /dev/null
+++ b/erts/emulator/beam/erl_bif_counters.c
@@ -0,0 +1,219 @@
+/*
+ * %CopyrightBegin%
+ *
+ * Copyright Ericsson AB 2018. 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.
+ * 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.
+ *
+ * %CopyrightEnd%
+ */
+
+/*
+ * Purpose:  High performance atomics.
+ */
+
+#ifdef HAVE_CONFIG_H
+#  include "config.h"
+#endif
+
+#include <stddef.h> /* offsetof */
+
+#include "sys.h"
+#include "export.h"
+#include "bif.h"
+#include "erl_threads.h"
+#include "big.h"
+#include "erl_binary.h"
+#include "erl_bif_unique.h"
+#include "erl_map.h"
+
+
+#define COUNTERS_PER_CACHE_LINE (ERTS_CACHE_LINE_SIZE / sizeof(erts_atomic64_t))
+
+typedef struct
+{
+    UWord arity;
+#ifdef DEBUG
+    UWord ulen;
+#endif
+    union {
+        erts_atomic64_t v[COUNTERS_PER_CACHE_LINE];
+        byte cache_line__[ERTS_CACHE_LINE_SIZE];
+    } u[1];
+}CountersRef;
+
+static int counters_destructor(Binary *unused)
+{
+    return 1;
+}
+
+
+static UWord ERTS_INLINE div_ceil(UWord dividend, UWord divisor)
+{
+    return (dividend + divisor - 1) / divisor;
+}
+
+BIF_RETTYPE erts_internal_counters_new_1(BIF_ALIST_1)
+{
+    CountersRef* p;
+    Binary* mbin;
+    UWord ui, vi, cnt;
+    Uint bytes, cache_lines;
+    Eterm* hp;
+
+    if (!term_to_UWord(BIF_ARG_1, &cnt)
+        || cnt == 0) {
+        BIF_ERROR(BIF_P, BADARG);
+    }
+
+    if (cnt > (ERTS_UWORD_MAX / (sizeof(erts_atomic64_t)*2*erts_no_schedulers)))
+        BIF_ERROR(BIF_P, SYSTEM_LIMIT);
+
+    cache_lines = erts_no_schedulers * div_ceil(cnt, COUNTERS_PER_CACHE_LINE);
+    bytes = offsetof(CountersRef, u) + cache_lines * ERTS_CACHE_LINE_SIZE;
+    mbin = erts_create_magic_binary_x(bytes,
+                                      counters_destructor,
+                                      ERTS_ALC_T_ATOMICS,
+                                      0);
+    p = ERTS_MAGIC_BIN_DATA(mbin);
+    p->arity = cnt;
+#ifdef DEBUG
+    p->ulen = cache_lines;
+#endif
+    ASSERT((byte*)&p->u[cache_lines] <= ((byte*)p + bytes));
+    for (ui=0; ui < cache_lines; ui++)
+        for (vi=0; vi < COUNTERS_PER_CACHE_LINE; vi++)
+            erts_atomic64_init_nob(&p->u[ui].v[vi], 0);
+    hp = HAlloc(BIF_P, ERTS_MAGIC_REF_THING_SIZE);
+    return erts_mk_magic_ref(&hp, &MSO(BIF_P), mbin);
+}
+
+static ERTS_INLINE int get_ref(Eterm ref, CountersRef** pp)
+{
+    Binary* mbin;
+    if (!is_internal_magic_ref(ref))
+        return 0;
+
+    mbin = erts_magic_ref2bin(ref);
+    if (ERTS_MAGIC_BIN_DESTRUCTOR(mbin) != counters_destructor)
+        return 0;
+    *pp = ERTS_MAGIC_BIN_DATA(mbin);
+    return 1;
+}
+
+static ERTS_INLINE int get_ref_cnt(Eterm ref, Eterm index,
+                                   CountersRef** pp,
+                                   erts_atomic64_t** app,
+                                   UWord sched_ix)
+{
+    CountersRef* p;
+    UWord ix, ui, vi;
+    if (!get_ref(ref, &p) || !term_to_UWord(index, &ix) || --ix >= p->arity)
+        return 0;
+    ui = (ix / COUNTERS_PER_CACHE_LINE) * erts_no_schedulers + sched_ix;
+    vi = ix % COUNTERS_PER_CACHE_LINE;
+    ASSERT(ui < p->ulen);
+    *pp = p;
+    *app = &p->u[ui].v[vi];
+    return 1;
+}
+
+static ERTS_INLINE int get_ref_my_cnt(Eterm ref, Eterm index,
+                                      CountersRef** pp,
+                                      erts_atomic64_t** app)
+{
+    ErtsSchedulerData *esdp = erts_get_scheduler_data();
+    ASSERT(esdp && !ERTS_SCHEDULER_IS_DIRTY(esdp));
+    return get_ref_cnt(ref, index, pp, app, esdp->no - 1);
+}
+
+static ERTS_INLINE int get_ref_first_cnt(Eterm ref, Eterm index,
+                                         CountersRef** pp,
+                                         erts_atomic64_t** app)
+{
+    return get_ref_cnt(ref, index, pp, app, 0);
+}
+
+static ERTS_INLINE int get_incr(CountersRef* p, Eterm term, erts_aint64_t *valp)
+{
+    return (term_to_Sint64(term, (Sint64*)valp)
+            || term_to_Uint64(term, (Uint64*)valp));
+}
+
+static ERTS_INLINE Eterm bld_counter(Process* proc, CountersRef* p,
+                                     erts_aint64_t val)
+{
+    if (IS_SSMALL(val))
+        return make_small((Sint) val);
+    else {
+        Uint hsz = ERTS_SINT64_HEAP_SIZE(val);
+        Eterm* hp = HAlloc(proc, hsz);
+        return erts_sint64_to_big(val, &hp);
+    }
+}
+
+BIF_RETTYPE erts_internal_counters_get_2(BIF_ALIST_2)
+{
+    CountersRef* p;
+    erts_atomic64_t* ap;
+    erts_aint64_t acc = 0;
+    int j;
+
+    if (!get_ref_first_cnt(BIF_ARG_1, BIF_ARG_2, &p, &ap)) {
+        BIF_ERROR(BIF_P, BADARG);
+    }
+    for (j = erts_no_schedulers; j ; --j) {
+        acc += erts_atomic64_read_nob(ap);
+        ap = (erts_atomic64_t*) ((byte*)ap + ERTS_CACHE_LINE_SIZE);
+    }
+    return bld_counter(BIF_P, p, acc);
+}
+
+BIF_RETTYPE erts_internal_counters_add_3(BIF_ALIST_3)
+{
+    CountersRef* p;
+    erts_atomic64_t* ap;
+    erts_aint64_t incr, sum;
+
+    if (!get_ref_my_cnt(BIF_ARG_1, BIF_ARG_2, &p, &ap)
+        || !get_incr(p, BIF_ARG_3, &incr)) {
+        BIF_ERROR(BIF_P, BADARG);
+    }
+    sum = incr + erts_atomic64_read_nob(ap);
+    erts_atomic64_set_nob(ap, sum);
+    return am_ok;
+}
+
+
+BIF_RETTYPE erts_internal_counters_info_1(BIF_ALIST_1)
+{
+    CountersRef* p;
+    Uint hsz = MAP2_SZ;
+    Eterm *hp;
+    UWord memory;
+    Eterm sz_val, mem_val;
+
+    if (!get_ref(BIF_ARG_1, &p))
+        BIF_ERROR(BIF_P, BADARG);
+
+    memory = erts_magic_ref2bin(BIF_ARG_1)->orig_size;
+    erts_bld_uword(NULL, &hsz, p->arity);
+    erts_bld_uword(NULL, &hsz, memory);
+
+    hp = HAlloc(BIF_P, hsz);
+    sz_val  = erts_bld_uword(&hp, NULL, p->arity);
+    mem_val = erts_bld_uword(&hp, NULL, memory);
+
+    return MAP2(hp, am_memory, mem_val,
+                am_size, sz_val);
+}
diff --git a/erts/emulator/beam/sys.h b/erts/emulator/beam/sys.h
index bb22548587..869a575cb4 100644
--- a/erts/emulator/beam/sys.h
+++ b/erts/emulator/beam/sys.h
@@ -325,6 +325,7 @@ typedef long          Sint  erts_align_attribute(sizeof(long));
 #define UWORD_CONSTANT(Const) Const##UL
 #define ERTS_UWORD_MAX ULONG_MAX
 #define ERTS_SWORD_MAX LONG_MAX
+#define ERTS_SWORD_MIN LONG_MIN
 #define ERTS_SIZEOF_ETERM SIZEOF_LONG
 #define ErtsStrToSint strtol
 #elif SIZEOF_VOID_P == SIZEOF_INT
@@ -335,6 +336,7 @@ typedef int          Sint  erts_align_attribute(sizeof(int));
 #define UWORD_CONSTANT(Const) Const##U
 #define ERTS_UWORD_MAX UINT_MAX
 #define ERTS_SWORD_MAX INT_MAX
+#define ERTS_SWORD_MIN INT_MIN
 #define ERTS_SIZEOF_ETERM SIZEOF_INT
 #define ErtsStrToSint strtol
 #elif SIZEOF_VOID_P == SIZEOF_LONG_LONG
@@ -345,6 +347,7 @@ typedef long long          Sint  erts_align_attribute(sizeof(long long));
 #define UWORD_CONSTANT(Const) Const##ULL
 #define ERTS_UWORD_MAX ULLONG_MAX
 #define ERTS_SWORD_MAX LLONG_MAX
+#define ERTS_SWORD_MIN LLONG_MIN
 #define ERTS_SIZEOF_ETERM SIZEOF_LONG_LONG
 #if defined(__WIN32__)
 #define ErtsStrToSint _strtoi64
diff --git a/erts/emulator/test/Makefile b/erts/emulator/test/Makefile
index d201ea6ee1..6a064ec8d4 100644
--- a/erts/emulator/test/Makefile
+++ b/erts/emulator/test/Makefile
@@ -33,6 +33,7 @@ MODULES= \
 	after_SUITE \
 	alloc_SUITE \
 	async_ports_SUITE \
+	atomics_SUITE \
 	beam_SUITE \
 	beam_literals_SUITE \
 	bif_SUITE \
@@ -50,6 +51,7 @@ MODULES= \
 	call_trace_SUITE \
 	code_SUITE \
 	code_parallel_load_SUITE \
+	counters_SUITE \
 	crypto_SUITE \
 	ddll_SUITE \
 	decode_packet_SUITE \
diff --git a/erts/emulator/test/atomics_SUITE.erl b/erts/emulator/test/atomics_SUITE.erl
new file mode 100644
index 0000000000..8c42354770
--- /dev/null
+++ b/erts/emulator/test/atomics_SUITE.erl
@@ -0,0 +1,147 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2018. 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.
+%% 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.
+%%
+%% %CopyrightEnd%
+%%
+-module(atomics_SUITE).
+
+-include_lib("common_test/include/ct.hrl").
+
+-compile(export_all).
+
+suite() -> [{ct_hooks,[ts_install_cth]}].
+
+all() ->
+    [signed, unsigned, bad, signed_limits, unsigned_limits].
+
+signed(Config) when is_list(Config) ->
+    Size = 10,
+    Ref = atomics:new(Size,[]),
+    #{size:=Size, memory:=Memory} = atomics:info(Ref),
+    {_,true} = {Memory, Memory > Size*8},
+    {_,true} = {Memory, Memory < Size*max_atomic_sz() + 100},
+    [signed_do(Ref, Ix) || Ix <- lists:seq(1, Size)],
+    ok.
+
+signed_do(Ref, Ix) ->
+    0 = atomics:get(Ref, Ix),
+    ok = atomics:put(Ref, Ix, 3),
+    ok = atomics:add(Ref, Ix, 14),
+    17 = atomics:get(Ref, Ix),
+    20 = atomics:add_get(Ref, Ix, 3),
+    -3 = atomics:add_get(Ref, Ix, -23),
+    17 = atomics:add_get(Ref, Ix, 20),
+    ok = atomics:sub(Ref, Ix, 4),
+    13 = atomics:get(Ref, Ix),
+    -7 = atomics:sub_get(Ref, Ix, 20),
+    3  = atomics:sub_get(Ref, Ix, -10),
+    3  = atomics:exchange(Ref, Ix, 666),
+    ok = atomics:compare_exchange(Ref, Ix, 666, 777),
+    777 = atomics:compare_exchange(Ref, Ix, 666, -666),
+    ok.
+
+unsigned(Config) when is_list(Config) ->
+    Size = 10,
+    Ref = atomics:new(Size,[{signed, false}]),
+    #{size:=Size, memory:=Memory} = atomics:info(Ref),
+    true = Memory > Size*8,
+    true = Memory < Size*max_atomic_sz() + 100,
+    [unsigned_do(Ref, Ix) || Ix <- lists:seq(1, Size)],
+    ok.
+
+unsigned_do(Ref, Ix) ->
+    0 = atomics:get(Ref, Ix),
+    ok = atomics:put(Ref, Ix, 3),
+    ok = atomics:add(Ref, Ix, 14),
+    17 = atomics:get(Ref, Ix),
+    20 = atomics:add_get(Ref, Ix, 3),
+    ok = atomics:sub(Ref, Ix, 7),
+    13 = atomics:get(Ref, Ix),
+    3  = atomics:sub_get(Ref, Ix, 10),
+    3  = atomics:exchange(Ref, Ix, 666),
+    ok = atomics:compare_exchange(Ref, Ix, 666, 777),
+    777 = atomics:compare_exchange(Ref, Ix, 666, 888),
+    ok.
+
+bad(Config) when is_list(Config) ->
+    {'EXIT',{badarg,_}} = (catch atomics:new(0,[])),
+    {'EXIT',{badarg,_}} = (catch atomics:new(10,[bad])),
+    {'EXIT',{badarg,_}} = (catch atomics:new(10,[{signed,bad}])),
+    {'EXIT',{badarg,_}} = (catch atomics:new(10,[{signed,true}, bad])),
+    {'EXIT',{badarg,_}} = (catch atomics:new(10,[{signed,false} | bad])),
+    Ref = atomics:new(10,[]),
+    {'EXIT',{badarg,_}} = (catch atomics:get(1742, 7)),
+    {'EXIT',{badarg,_}} = (catch atomics:get(make_ref(), 7)),
+    {'EXIT',{badarg,_}} = (catch atomics:get(Ref, -1)),
+    {'EXIT',{badarg,_}} = (catch atomics:get(Ref, 0)),
+    {'EXIT',{badarg,_}} = (catch atomics:get(Ref, 11)),
+    {'EXIT',{badarg,_}} = (catch atomics:get(Ref, 7.0)),
+    ok.
+
+
+signed_limits(Config) when is_list(Config) ->
+    Bits = 64,
+    Max = (1 bsl (Bits-1)) - 1,
+    Min = -(1 bsl (Bits-1)),
+
+    Ref = atomics:new(1,[{signed, true}]),
+    #{max:=Max, min:=Min} = atomics:info(Ref),
+    0 = atomics:get(Ref, 1),
+    ok = atomics:add(Ref, 1, Max),
+    Min = atomics:add_get(Ref, 1, 1),
+    Max = atomics:sub_get(Ref, 1, 1),
+
+    IncrMax = (Max bsl 1) bor 1,
+    ok = atomics:put(Ref, 1, 0),
+    ok = atomics:add(Ref, 1, IncrMax),
+    -1 = atomics:get(Ref, 1),
+    {'EXIT',{badarg,_}} = (catch atomics:add(Ref, 1, IncrMax+1)),
+    {'EXIT',{badarg,_}} = (catch atomics:add(Ref, 1, Min-1)),
+
+    ok.
+
+unsigned_limits(Config) when is_list(Config) ->
+    Bits = 64,
+    Max = (1 bsl Bits) - 1,
+    Min = 0,
+
+    Ref = atomics:new(1,[{signed,false}]),
+    #{max:=Max, min:=Min} = atomics:info(Ref),
+    0 = atomics:get(Ref, 1),
+    ok = atomics:add(Ref, 1, Max),
+    Min = atomics:add_get(Ref, 1, 1),
+    Max = atomics:sub_get(Ref, 1, 1),
+
+    {'EXIT',{badarg,_}} = (catch atomics:add(Ref, 1, Max+1)),
+    IncrMin = -(1 bsl (Bits-1)),
+    ok = atomics:put(Ref, 1, -IncrMin),
+    ok = atomics:add(Ref, 1, IncrMin),
+    0 = atomics:get(Ref, 1),
+    {'EXIT',{badarg,_}} = (catch atomics:add(Ref, 1, IncrMin-1)),
+
+    ok.
+
+max_atomic_sz() ->
+    case erlang:system_info({wordsize, external}) of
+        4 -> 16;
+        8 ->
+            EI = erlang:system_info(ethread_info),
+            case lists:keyfind("64-bit native atomics", 1, EI) of
+                {_, "no", _} -> 16;
+                _ -> 8
+            end
+    end.
diff --git a/erts/emulator/test/counters_SUITE.erl b/erts/emulator/test/counters_SUITE.erl
new file mode 100644
index 0000000000..7de164096b
--- /dev/null
+++ b/erts/emulator/test/counters_SUITE.erl
@@ -0,0 +1,112 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2018. 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.
+%% 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.
+%%
+%% %CopyrightEnd%
+%%
+-module(counters_SUITE).
+
+-include_lib("common_test/include/ct.hrl").
+
+-compile(export_all).
+
+suite() -> [{ct_hooks,[ts_install_cth]}].
+
+all() ->
+    [basic, bad, limits].
+
+basic(Config) when is_list(Config) ->
+    Size = 10,
+    [begin
+         Ref = counters:new(Size,[Type]),
+         #{size:=Size, memory:=Memory} = counters:info(Ref),
+         check_memory(Type, Memory, Size),
+         [basic_do(Ref, Ix) || Ix <- lists:seq(1, Size)]
+     end
+     || Type <- [atomics, write_concurrency]],
+    ok.
+
+basic_do(Ref, Ix) ->
+    0 = counters:get(Ref, Ix),
+    ok = counters:add(Ref, Ix, 3),
+    3  = counters:get(Ref, Ix),
+    ok = counters:add(Ref, Ix, 14),
+    17  = counters:get(Ref, Ix),
+    ok = counters:add(Ref, Ix, -20),
+    -3  = counters:get(Ref, Ix),
+    ok = counters:add(Ref, Ix, 100),
+    97 = counters:get(Ref, Ix),
+    ok = counters:sub(Ref, Ix, 20),
+    77 = counters:get(Ref, Ix),
+    ok = counters:sub(Ref, Ix, -10),
+    87 = counters:get(Ref, Ix),
+    ok.
+
+check_memory(atomics, Memory, Size) ->
+    {_,true} = {Memory, Memory > Size*8},
+    {_,true} = {Memory, Memory < Size*max_atomic_sz() + 100};
+check_memory(write_concurrency, Memory, Size) ->
+    NScheds = erlang:system_info(schedulers),
+    {_,true} = {Memory, Memory > NScheds*Size*8},
+    {_,true} = {Memory, Memory < NScheds*(Size+7)*max_atomic_sz() + 100}.
+
+max_atomic_sz() ->
+    case erlang:system_info({wordsize, external}) of
+        4 -> 16;
+        8 ->
+            EI = erlang:system_info(ethread_info),
+            case lists:keyfind("64-bit native atomics", 1, EI) of
+                {_, "no", _} -> 16;
+                _ -> 8
+            end
+    end.
+
+bad(Config) when is_list(Config) ->
+    {'EXIT',{badarg,_}} = (catch counters:new(0,[])),
+    {'EXIT',{badarg,_}} = (catch counters:new(10,[bad])),
+    {'EXIT',{badarg,_}} = (catch counters:new(10,[atomic, bad])),
+    {'EXIT',{badarg,_}} = (catch counters:new(10,[write_concurrency | bad])),
+    Ref = counters:new(10,[]),
+    {'EXIT',{badarg,_}} = (catch counters:get(1742, 7)),
+    {'EXIT',{badarg,_}} = (catch counters:get(make_ref(), 7)),
+    {'EXIT',{badarg,_}} = (catch counters:get(Ref, -1)),
+    {'EXIT',{badarg,_}} = (catch counters:get(Ref, 0)),
+    {'EXIT',{badarg,_}} = (catch counters:get(Ref, 11)),
+    {'EXIT',{badarg,_}} = (catch counters:get(Ref, 7.0)),
+    ok.
+
+
+limits(Config) when is_list(Config) ->
+    Bits = 64,
+    Max = (1 bsl (Bits-1)) - 1,
+    Min = -(1 bsl (Bits-1)),
+
+    Ref = counters:new(1,[]),
+    0 = counters:get(Ref, 1),
+    ok = counters:add(Ref, 1, Max),
+    ok = counters:add(Ref, 1, 1),
+    Min = counters:get(Ref, 1),
+    ok  = counters:sub(Ref, 1, 1),
+    Max = counters:get(Ref, 1),
+
+    IncrMax = (Max bsl 1) bor 1,
+    ok = counters:sub(Ref, 1, counters:get(Ref, 1)),
+    ok = counters:add(Ref, 1, IncrMax),
+    -1 = counters:get(Ref, 1),
+    {'EXIT',{badarg,_}} = (catch counters:add(Ref, 1, IncrMax+1)),
+    {'EXIT',{badarg,_}} = (catch counters:add(Ref, 1, Min-1)),
+
+    ok.
diff --git a/erts/preloaded/ebin/atomics.beam b/erts/preloaded/ebin/atomics.beam
new file mode 100644
index 0000000000..1de97fa668
--- /dev/null
+++ b/erts/preloaded/ebin/atomics.beam
diff --git a/erts/preloaded/ebin/counters.beam b/erts/preloaded/ebin/counters.beam
new file mode 100644
index 0000000000..caaa6167e1
--- /dev/null
+++ b/erts/preloaded/ebin/counters.beam
diff --git a/erts/preloaded/ebin/erts_internal.beam b/erts/preloaded/ebin/erts_internal.beam
index a8a0dfcd62..2b98e87843 100644
--- a/erts/preloaded/ebin/erts_internal.beam
+++ b/erts/preloaded/ebin/erts_internal.beam
diff --git a/erts/preloaded/src/Makefile b/erts/preloaded/src/Makefile
index 7564086b1b..c655bff72e 100644
--- a/erts/preloaded/src/Makefile
+++ b/erts/preloaded/src/Makefile
@@ -48,6 +48,8 @@ PRE_LOADED_ERL_MODULES = \
 	erl_tracer \
 	erts_literal_area_collector \
 	erts_dirty_process_signal_handler \
+	atomics \
+	counters \
         persistent_term
 
 PRE_LOADED_BEAM_MODULES = \
diff --git a/erts/preloaded/src/atomics.erl b/erts/preloaded/src/atomics.erl
new file mode 100644
index 0000000000..d1fe5e65cf
--- /dev/null
+++ b/erts/preloaded/src/atomics.erl
@@ -0,0 +1,119 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2018. 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.
+%% 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.
+%%
+%% %CopyrightEnd%
+%%
+
+%% Purpose : Main atomics API module.
+
+-module(atomics).
+
+-export([new/2,
+         put/3, get/2,
+         add/3, add_get/3,
+         sub/3, sub_get/3,
+         exchange/3, compare_exchange/4,
+         info/1]).
+
+-export_type([atomics_ref/0]).
+
+-opaque atomics_ref() :: reference().
+
+-define(OPT_SIGNED, (1 bsl 0)).
+-define(OPT_DEFAULT, ?OPT_SIGNED).
+
+-spec new(Arity, Opts) -> atomics_ref() when
+      Arity :: pos_integer(),
+      Opts :: [Opt],
+      Opt :: {signed, boolean()}.
+new(Arity, Opts) ->
+    erts_internal:atomics_new(Arity, encode_opts(Opts, ?OPT_DEFAULT)).
+
+encode_opts([{signed, true}|T], Acc) ->
+    encode_opts(T, Acc bor ?OPT_SIGNED);
+encode_opts([{signed, false}|T], Acc) ->
+    encode_opts(T, Acc band (bnot ?OPT_SIGNED));
+encode_opts([], Acc) ->
+    Acc;
+encode_opts(_, _) ->
+    erlang:error(badarg).
+
+-spec put(Ref, Ix, Value) -> ok when
+      Ref  :: atomics_ref(),
+      Ix :: integer(),
+      Value :: integer().
+put(_Ref, _Ix, _Value) ->
+    erlang:nif_error(undef).
+
+-spec get(Ref, Ix) -> integer() when
+      Ref  :: atomics_ref(),
+      Ix :: integer().
+get(_Ref, _Ix) ->
+    erlang:nif_error(undef).
+
+-spec add(Ref, Ix, Incr) -> ok when
+      Ref  :: atomics_ref(),
+      Ix :: integer(),
+      Incr :: integer().
+add(_Ref, _Ix, _Incr) ->
+    erlang:nif_error(undef).
+
+-spec add_get(Ref, Ix, Incr) -> integer() when
+      Ref  :: atomics_ref(),
+      Ix :: integer(),
+      Incr :: integer().
+add_get(_Ref, _Ix, _Incr) ->
+    erlang:nif_error(undef).
+
+-spec sub(Ref, Ix, Decr) -> ok when
+      Ref  :: atomics_ref(),
+      Ix :: integer(),
+      Decr :: integer().
+sub(Ref, Ix, Decr) ->
+    ?MODULE:add(Ref, Ix, -Decr).
+
+-spec sub_get(Ref, Ix, Decr) -> integer() when
+      Ref  :: atomics_ref(),
+      Ix :: integer(),
+      Decr :: integer().
+sub_get(Ref, Ix, Decr) ->
+    ?MODULE:add_get(Ref, Ix, -Decr).
+
+-spec exchange(Ref, Ix, Desired) -> integer() when
+      Ref  :: atomics_ref(),
+      Ix :: integer(),
+      Desired :: integer().
+exchange(_Ref, _Ix, _Desired) ->
+    erlang:nif_error(undef).
+
+-spec compare_exchange(Ref, Ix, Expected, Desired) -> ok | integer() when
+      Ref  :: atomics_ref(),
+      Ix :: integer(),
+      Expected :: integer(),
+      Desired :: integer().
+compare_exchange(_Ref, _Ix, _Expected, _Desired) ->
+    erlang:nif_error(undef).
+
+-spec info(Ref) -> Info when
+      Ref  :: atomics_ref(),
+      Info :: #{'size':=Size,'max':=Max,'min':=Min,'memory':=Memory},
+      Size :: non_neg_integer(),
+      Max :: integer(),
+      Min :: integer(),
+      Memory :: non_neg_integer().
+info(_Ref) ->
+    erlang:nif_error(undef).
diff --git a/erts/preloaded/src/counters.erl b/erts/preloaded/src/counters.erl
new file mode 100644
index 0000000000..67354f648d
--- /dev/null
+++ b/erts/preloaded/src/counters.erl
@@ -0,0 +1,90 @@
+%%
+%% %CopyrightBegin%
+%%
+%% Copyright Ericsson AB 2018. 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.
+%% 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.
+%%
+%% %CopyrightEnd%
+%%
+
+%% Purpose : Main atomics API module.
+
+-module(counters).
+
+-export([new/2,
+         get/2,
+         add/3,
+         sub/3,
+         info/1]).
+
+-export_type([counters_ref/0]).
+
+-opaque counters_ref() :: {atomics, reference()} | {write_concurrency, reference()}.
+
+-spec new(Size, Opts) -> counters_ref() when
+      Size :: pos_integer(),
+      Opts :: [Opt],
+      Opt :: atomics | write_concurrency.
+new(Size, [atomics]) ->
+    {atomics, atomics:new(Size, [{signed, true}])};
+new(Size, [write_concurrency]) ->
+    {write_concurrency, erts_internal:counters_new(Size)};
+new(Size, []) ->
+    new(Size, [atomics]);
+new(_, _) ->
+    erlang:error(badarg).
+
+-spec get(Ref, Ix) -> integer() when
+      Ref  :: counters_ref(),
+      Ix :: integer().
+get({atomics,Ref}, Ix) ->
+    atomics:get(Ref, Ix);
+get({write_concurrency, Ref}, Ix) ->
+    erts_internal:counters_get(Ref, Ix);
+get(_, _) ->
+    erlang:error(badarg).
+
+
+
+-spec add(Ref, Ix, Incr) -> ok when
+      Ref  :: counters_ref(),
+      Ix :: integer(),
+      Incr :: integer().
+add({atomics, Ref}, Ix, Incr) ->
+    atomics:add(Ref, Ix, Incr);
+add({write_concurrency, Ref}, Ix, Incr) ->
+    erts_internal:counters_add(Ref, Ix, Incr);
+add(_, _, _) ->
+    erlang:error(badarg).
+
+
+-spec sub(Ref, Ix, Decr) -> ok when
+      Ref  :: counters_ref(),
+      Ix :: integer(),
+      Decr :: integer().
+sub(Ref, Ix, Decr) ->
+    add(Ref, Ix, -Decr).
+
+-spec info(Ref) -> Info when
+      Ref  :: counters_ref(),
+      Info :: #{'size':=Size, 'memory':=Memory},
+      Size :: non_neg_integer(),
+      Memory :: non_neg_integer().
+info({atomics, Ref}) ->
+    atomics:info(Ref);
+info({write_concurrency, Ref}) ->
+    erts_internal:counters_info(Ref);
+info(_) ->
+    erlang:error(badarg).
+
diff --git a/erts/preloaded/src/erts.app.src b/erts/preloaded/src/erts.app.src
index dc97b86d8c..13fbbc7ff7 100644
--- a/erts/preloaded/src/erts.app.src
+++ b/erts/preloaded/src/erts.app.src
@@ -33,12 +33,14 @@
 		prim_file,
 		prim_inet,
 		prim_zip,
+                atomics,
+                counters,
 		zlib
 	    ]},
 	{registered, []},
 	{applications, []},
 	{env, []},
-	{runtime_dependencies, ["stdlib-3.5", "kernel-6.1", "sasl-3.0.1"]}
+	{runtime_dependencies, ["stdlib-3.5", "kernel-6.1", "sasl-@OTP-13468@"]}
     ]}.
 
 %% vim: ft=erlang
diff --git a/erts/preloaded/src/erts_internal.erl b/erts/preloaded/src/erts_internal.erl
index 63b786a473..d491a505c6 100644
--- a/erts/preloaded/src/erts_internal.erl
+++ b/erts/preloaded/src/erts_internal.erl
@@ -92,6 +92,11 @@
 
 -export([erase_persistent_terms/0]).
 
+-export([atomics_new/2]).
+
+-export([counters_new/1, counters_get/2, counters_add/3,
+         counters_info/1]).
+
 %%
 %% Await result of send to port
 %%
@@ -697,3 +702,23 @@ create_dist_channel(_Node, _DistCtrlr, _Flags, _Ver) ->
 -spec erase_persistent_terms() -> 'ok'.
 erase_persistent_terms() ->
     erlang:nif_error(undefined).
+
+-spec atomics_new(pos_integer(), pos_integer()) -> reference().
+atomics_new(_Arity, _EncOpts) ->
+    erlang:nif_error(undef).
+
+-spec counters_new(pos_integer()) -> reference().
+counters_new(_Size) ->
+    erlang:nif_error(undef).
+
+-spec counters_get(reference(), pos_integer()) -> integer().
+counters_get(_Ref, _Ix) ->
+    erlang:nif_error(undef).
+
+-spec counters_add(reference(), pos_integer(), integer()) -> ok.
+counters_add(_Ref, _Ix, _Incr) ->
+    erlang:nif_error(undef).
+
+-spec counters_info(reference()) -> #{}.
+counters_info(_Ref) ->
+    erlang:nif_error(undef).
diff --git a/lib/sasl/src/sasl.app.src b/lib/sasl/src/sasl.app.src
index 688aff16f1..5d45af0b50 100644
--- a/lib/sasl/src/sasl.app.src
+++ b/lib/sasl/src/sasl.app.src
@@ -43,5 +43,5 @@
     {env, []},
     {mod, {sasl, []}},
     {runtime_dependencies, ["tools-2.6.14","stdlib-3.4","kernel-5.3",
-			    "erts-9.0"]}]}.
+			    "erts-@OTP-13468@"]}]}.
 
diff --git a/lib/sasl/src/systools_make.erl b/lib/sasl/src/systools_make.erl
index 072d4ed555..101701cec6 100644
--- a/lib/sasl/src/systools_make.erl
+++ b/lib/sasl/src/systools_make.erl
@@ -1562,7 +1562,7 @@ mandatory_modules() ->
 
 preloaded() ->
     %% Sorted
-    [erl_init,erl_prim_loader,erl_tracer,erlang,
+    [atomics,counters,erl_init,erl_prim_loader,erl_tracer,erlang,
      erts_code_purger,erts_dirty_process_signal_handler,
      erts_internal,erts_literal_area_collector,
      init,persistent_term,prim_buffer,prim_eval,prim_file,