erts: erts_mmap supercarrier management and erts_mseg usage

* Coalescing and trimming of free segments in supercarrier
* Management of super aligned and super unaligned areas in
  supercarrier
* Management of reservation of physical memory
* erts_mseg usage of erts_mmap

4 files changed, 1354 insertions, 749 deletions

diff --git a/erts/emulator/sys/common/erl_mmap.c b/erts/emulator/sys/common/erl_mmap.c
index a16ee7ae39..aac01bf93c 100644
--- a/erts/emulator/sys/common/erl_mmap.c
+++ b/erts/emulator/sys/common/erl_mmap.c
@@ -20,11 +20,57 @@
 #  include "config.h"
 #endif
 
-#include <sys.h>
-#include <erl_mmap.h>
+#include "sys.h"
 #include <stddef.h>
+#include "erl_smp.h"
+#include "erl_mmap.h"
 
-#ifdef DEBUG
+#if defined(DEBUG) || 0
+#  undef ERTS_MMAP_DEBUG
+#  define ERTS_MMAP_DEBUG
+#endif
+
+/* #define ERTS_MMAP_DEBUG_FILL_AREAS */
+
+#ifdef ERTS_MMAP_DEBUG
+#  define ERTS_MMAP_ASSERT(A)						\
+    ((void) (!(A)							\
+	     ? erts_mmap_assert_failed(#A, __func__, __FILE__, __LINE__)\
+	     : 1))
+static int
+erts_mmap_assert_failed(const char *a, const char *func, const char *file, int line)
+{
+    erts_fprintf(stderr, "%s:%d:%s() Assertion failed: %s\n",
+		 (char *) file, line, (char *) func, (char *) a);
+    abort();
+    return 0;
+}
+#else
+#  define ERTS_MMAP_ASSERT(A) ((void) 1)
+#endif
+
+/*
+ * `mmap_state.sa.bot` and `mmap_state.sua.top` are read only after
+ * initialization, but the other pointers are not; i.e., only
+ * ERTS_MMAP_IN_SUPERCARRIER() is allowed without the mutex held.
+ */
+#define ERTS_MMAP_IN_SUPERCARRIER(PTR)					\
+    (((UWord) (PTR)) - ((UWord) mmap_state.sa.bot)			\
+     < ((UWord) mmap_state.sua.top) - ((UWord) mmap_state.sa.bot))
+#define ERTS_MMAP_IN_SUPERALIGNED_AREA(PTR)				\
+    (ERTS_SMP_LC_ASSERT(erts_lc_mtx_is_locked(&mmap_state.mtx)),	\
+     (((UWord) (PTR)) - ((UWord) mmap_state.sa.bot)			\
+      < ((UWord) mmap_state.sa.top) - ((UWord) mmap_state.sa.bot)))
+#define ERTS_MMAP_IN_SUPERUNALIGNED_AREA(PTR)				\
+    (ERTS_SMP_LC_ASSERT(erts_lc_mtx_is_locked(&mmap_state.mtx)),	\
+     (((UWord) (PTR)) - ((UWord) mmap_state.sua.bot)			\
+      < ((UWord) mmap_state.sua.top) - ((UWord) mmap_state.sua.bot)))
+
+int erts_have_erts_mmap;
+UWord erts_page_inv_mask;
+
+#if defined(DEBUG) || defined(ERTS_MMAP_DEBUG)
+#  undef RBT_DEBUG
 #  define RBT_DEBUG
 #endif
 #ifdef RBT_DEBUG
@@ -60,7 +106,7 @@ typedef struct {
 #define SET_RED(N)   ((N)->flags |= RED_FLG)
 #define SET_BLACK(N) ((N)->flags &= ~RED_FLG)
 
-#define HARD_DEBUG /*SVERK*/
+/* #define HARD_DEBUG */
 #ifdef HARD_DEBUG
 #  define HARD_CHECK_IS_MEMBER(ROOT,NODE) rbt_assert_is_member(ROOT,NODE)
 #  define HARD_CHECK_TREE(TREE,SZ) check_tree(TREE, SZ)
@@ -79,6 +125,134 @@ typedef struct {
     char* end;
 }ErtsFreeSegDesc;
 
+typedef struct {
+    RBTree stree;
+    RBTree atree;
+}ErtsFreeSegMap;
+
+static struct {
+    int (*reserve_physical)(char *, UWord);
+    void (*unreserve_physical)(char *, UWord);
+    int supercarrier;
+    int no_os_mmap;
+    /*
+     * Super unaligend area is located above super aligned
+     * area. That is, `sa.bot` is beginning of the super
+     * carrier, `sua.top` is the end of the super carrier,
+     * and sa.top and sua.bot moves towards eachother.
+     */
+    struct {
+	char *top;
+	char *bot;
+	ErtsFreeSegMap map;
+    } sua;
+    struct {
+	char *top;
+	char *bot;
+	ErtsFreeSegMap map;
+    } sa;
+#if HAVE_MMAP && (!defined(MAP_ANON) && !defined(MAP_ANONYMOUS))
+    int mmap_fd;
+#endif
+    erts_smp_mtx_t mtx;
+    char *desc_free_list;
+    struct {
+	struct {
+	    UWord total;
+	    struct {
+		UWord total;
+		UWord sa;
+		UWord sua;
+	    } used;
+	} supercarrier;
+	struct {
+	    UWord used;
+	} os;
+    } size;
+} mmap_state;
+
+#define ERTS_MMAP_SIZE_SC_SA_INC(SZ) 						\
+    do {									\
+	mmap_state.size.supercarrier.used.total += (SZ);			\
+	mmap_state.size.supercarrier.used.sa += (SZ);				\
+	ERTS_MMAP_ASSERT(mmap_state.size.supercarrier.used.total		\
+			 <= mmap_state.size.supercarrier.total);		\
+	ERTS_MMAP_ASSERT(mmap_state.size.supercarrier.used.sa			\
+			 <= mmap_state.size.supercarrier.used.total);		\
+    } while (0)
+#define ERTS_MMAP_SIZE_SC_SA_DEC(SZ) 						\
+    do {									\
+	ERTS_MMAP_ASSERT(mmap_state.size.supercarrier.used.total >= (SZ));	\
+	mmap_state.size.supercarrier.used.total -= (SZ);			\
+	ERTS_MMAP_ASSERT(mmap_state.size.supercarrier.used.sa >= (SZ));		\
+	mmap_state.size.supercarrier.used.sa -= (SZ);				\
+    } while (0)
+#define ERTS_MMAP_SIZE_SC_SUA_INC(SZ) 						\
+    do {									\
+	mmap_state.size.supercarrier.used.total += (SZ);			\
+	mmap_state.size.supercarrier.used.sua += (SZ);				\
+	ERTS_MMAP_ASSERT(mmap_state.size.supercarrier.used.total		\
+			 <= mmap_state.size.supercarrier.total);		\
+	ERTS_MMAP_ASSERT(mmap_state.size.supercarrier.used.sua			\
+			 <= mmap_state.size.supercarrier.used.total);		\
+    } while (0)
+#define ERTS_MMAP_SIZE_SC_SUA_DEC(SZ) 						\
+    do {									\
+	ERTS_MMAP_ASSERT(mmap_state.size.supercarrier.used.total >= (SZ));	\
+	mmap_state.size.supercarrier.used.total -= (SZ);			\
+	ERTS_MMAP_ASSERT(mmap_state.size.supercarrier.used.sua >= (SZ));	\
+	mmap_state.size.supercarrier.used.sua -= (SZ);				\
+    } while (0)
+#define ERTS_MMAP_SIZE_OS_INC(SZ)						\
+    do {									\
+	ERTS_MMAP_ASSERT(mmap_state.size.os.used + (SZ) >= (SZ));		\
+	mmap_state.size.os.used += (SZ);					\
+    } while (0)
+#define ERTS_MMAP_SIZE_OS_DEC(SZ) 						\
+    do {									\
+	ERTS_MMAP_ASSERT(mmap_state.size.os.used >= (SZ));			\
+	mmap_state.size.os.used -= (SZ);					\
+    } while (0)
+
+static void
+add_free_desc_area(char *start, char *end)
+{
+    if (end > start && sizeof(ErtsFreeSegDesc) <= end - start) {
+	ErtsFreeSegDesc *prev_desc, *desc;
+	char *desc_end;
+
+	prev_desc = (ErtsFreeSegDesc *) start;
+	prev_desc->start = mmap_state.desc_free_list;
+	desc = (ErtsFreeSegDesc *) (start + sizeof(ErtsFreeSegDesc));
+	desc_end = start + 2*sizeof(ErtsFreeSegDesc);
+
+	while (desc_end <= end) {
+	    desc->start = (char *) prev_desc;
+	    prev_desc = desc;
+	    desc = (ErtsFreeSegDesc *) desc_end;
+	    desc_end += sizeof(ErtsFreeSegDesc);
+	}
+	mmap_state.desc_free_list = (char *) prev_desc;
+    }
+}
+
+static ERTS_INLINE ErtsFreeSegDesc *
+alloc_desc(void)
+{
+    ErtsFreeSegDesc *res;
+    res = (ErtsFreeSegDesc *) mmap_state.desc_free_list;
+    if (res)
+	mmap_state.desc_free_list = res->start;
+    return res;
+}
+
+static ERTS_INLINE void
+free_desc(ErtsFreeSegDesc *desc)
+{
+    desc->start = mmap_state.desc_free_list;
+    mmap_state.desc_free_list = (char *) desc;
+}
+
 static ERTS_INLINE ErtsFreeSegDesc* anode_to_desc(RBTNode* anode)
 {
     return (ErtsFreeSegDesc*) ((char*)anode - offsetof(ErtsFreeSegDesc, anode));
@@ -94,12 +268,6 @@ static ERTS_INLINE ErtsFreeSegDesc* node_to_desc(enum SortOrder order, RBTNode*
     return order==ADDR_ORDER ? anode_to_desc(node) : snode_to_desc(node);
 }
 
-typedef struct {
-    RBTree stree;
-    RBTree atree;
-}ErtsFreeSegMap;
-
-
 #ifdef HARD_DEBUG
 static ERTS_INLINE SWord cmp_blocks(enum SortOrder order,
                                      RBTNode* lhs, RBTNode* rhs)
@@ -671,19 +839,927 @@ static ErtsFreeSegDesc* lookup_free_seg(ErtsFreeSegMap* map, SWord need_sz)
     return best_desc;
 }
 
+#if ERTS_HAVE_OS_MMAP
+/* Implementation of os_mmap()/os_munmap()/os_mremap()... */
+
+#if HAVE_MMAP
+#  define ERTS_MMAP_PROT		(PROT_READ|PROT_WRITE)
+#  if defined(MAP_ANONYMOUS)
+#    define ERTS_MMAP_FLAGS		(MAP_ANON|MAP_PRIVATE)
+#    define ERTS_MMAP_FD		(-1)
+#  elif defined(MAP_ANON)
+#    define ERTS_MMAP_FLAGS		(MAP_ANON|MAP_PRIVATE)
+#    define ERTS_MMAP_FD		(-1)
+#  else
+#    define ERTS_MMAP_FLAGS		(MAP_PRIVATE)
+#    define ERTS_MMAP_FD		mmap_state.mmap_fd
+#  endif
+#endif
 
-void erts_mmap_init(ErtsMMapInit* init)
+static ERTS_INLINE void *
+os_mmap(UWord size, int try_superalign)
 {
-#ifdef HARD_DEBUG
-    erts_fprintf(stderr, "SVERK: scs = %bpu\n", init->scs);
-    erts_fprintf(stderr, "SVERK: sco = %i\n", init->sco);
-    erts_fprintf(stderr, "SVERK: scmgc = %i\n", init->scmgc);
+#if HAVE_MMAP
+    void *res;
+#ifdef MAP_ALIGN
+    if (try_superalign)
+	res = mmap((void *) ERTS_SUPERALIGNED_SIZE, size, ERTS_MMAP_PROT,
+		   ERTS_MMAP_FLAGS|MAP_ALIGN, ERTS_MMAP_FD, 0);
+    else
+#endif
+	res = mmap((void *) 0, size, ERTS_MMAP_PROT,
+		   ERTS_MMAP_FLAGS, ERTS_MMAP_FD, 0);
+    if (res == MAP_FAILED)
+	return NULL;
+    return res;
+#elif HAVE_VIRTUALALLOC
+    return (void *) VirtualAlloc(NULL, (SIZE_T) size,
+				 MEM_COMMIT|MEM_RESERVE, PAGE_READWRITE);
+#else
+#  error "missing mmap() or similar"
+#endif
+}
+
+static ERTS_INLINE void
+os_munmap(void *ptr, UWord size)
+{
+#if HAVE_MMAP
+#ifdef ERTS_MMAP_DEBUG
+    int res =
+#endif
+	munmap(ptr, size);
+    ERTS_MMAP_ASSERT(res == 0);
+#elif HAVE_VIRTUALALLOC
+#ifdef DEBUG
+    BOOL res =
+#endif
+	VirtualFree((LPVOID) ptr, (SIZE_T) 0, MEM_RELEASE);
+    ERTS_MMAP_ASSERT(res != 0);
+#else
+#  error "missing munmap() or similar"
+#endif
+}
+
+#ifdef ERTS_HAVE_OS_MREMAP
+#  if HAVE_MREMAP
+#    if defined(__NetBSD__)
+#      define ERTS_MREMAP_FLAGS  (0)
+#    else
+#      define ERTS_MREMAP_FLAGS  (MREMAP_MAYMOVE)
+#    endif
+#  endif
+static ERTS_INLINE void *
+os_mremap(void *ptr, UWord old_size, UWord new_size, int try_superalign)
+{
+    void *new_seg;
+#if HAVE_MREMAP
+    new_seg = mremap(ptr, (size_t) old_size,
+#  if defined(__NetBSD__)
+		     NULL,
+#  endif
+		     (size_t) new_size, ERTS_MREMAP_FLAGS);
+    if (new_seg == (void *) MAP_FAILED)
+	return NULL;
+    return new_seg;
+#else
+#  error "missing mremap() or similar"
+#endif
+}
+#endif
+
+#ifdef ERTS_HAVE_OS_PHYSICAL_MEMORY_RESERVATION
+#if HAVE_MMAP
+
+#define ERTS_MMAP_RESERVE_PROT		(ERTS_MMAP_PROT)
+#define ERTS_MMAP_RESERVE_FLAGS		(ERTS_MMAP_FLAGS|MAP_FIXED)
+#define ERTS_MMAP_UNRESERVE_PROT	(PROT_NONE)
+#define ERTS_MMAP_UNRESERVE_FLAGS	(ERTS_MMAP_FLAGS|MAP_NORESERVE|MAP_FIXED)
+#define ERTS_MMAP_VIRTUAL_PROT		(PROT_NONE)
+#define ERTS_MMAP_VIRTUAL_FLAGS		(ERTS_MMAP_FLAGS|MAP_NORESERVE)
+
+static int
+os_reserve_physical(char *ptr, UWord size)
+{
+    void *res = mmap((void *) ptr, (size_t) size, ERTS_MMAP_RESERVE_PROT,
+		     ERTS_MMAP_RESERVE_FLAGS, ERTS_MMAP_FD, 0);
+    if (res == (void *) MAP_FAILED)
+	return 0;
+    return 1;
+}
+
+static void
+os_unreserve_physical(char *ptr, UWord size)
+{
+    void *res = mmap((void *) ptr, (size_t) size, ERTS_MMAP_UNRESERVE_PROT,
+		     ERTS_MMAP_UNRESERVE_FLAGS, ERTS_MMAP_FD, 0);
+    if (res == (void *) MAP_FAILED)
+	erl_exit(ERTS_ABORT_EXIT, "Failed to unreserve memory");
+}
+
+static void *
+os_mmap_virtual(char *ptr, UWord size)
+{
+    void *res = mmap((void *) ptr, (size_t) size, ERTS_MMAP_VIRTUAL_PROT,
+		     ERTS_MMAP_VIRTUAL_FLAGS, ERTS_MMAP_FD, 0);
+    if (res == (void *) MAP_FAILED)
+	return NULL;
+    return res;
+}
+
+#else
+#error "Missing reserve/unreserve physical memory implementation"
+#endif
+#endif /* ERTS_HAVE_OS_RESERVE_PHYSICAL_MEMORY */
+
+#endif /* ERTS_HAVE_OS_MMAP */
+
+static int reserve_noop(char *ptr, UWord size)
+{
+#ifdef ERTS_MMAP_DEBUG_FILL_AREAS
+    Uint32 *uip, *end = (Uint32 *) (ptr + size);
+
+    for (uip = (Uint32 *) ptr; uip < end; uip++)
+	ERTS_MMAP_ASSERT(*uip == (Uint32) 0xdeadbeef);
+    for (uip = (Uint32 *) ptr; uip < end; uip++)
+	*uip = (Uint32) 0xfeedfeed;
+#endif
+    return 1;
+}
+
+static void unreserve_noop(char *ptr, UWord size)
+{
+#ifdef ERTS_MMAP_DEBUG_FILL_AREAS
+    Uint32 *uip, *end = (Uint32 *) (ptr + size);
+
+    for (uip = (Uint32 *) ptr; uip < end; uip++)
+	*uip = (Uint32) 0xdeadbeef;
+#endif
+}
+
+void *
+erts_mmap(Uint32 flags, UWord *sizep)
+{
+    char *seg;
+    UWord asize = ERTS_PAGEALIGNED_CEILING(*sizep);
+
+    /* Map in premapped supercarrier */
+    if (mmap_state.supercarrier && !(ERTS_MMAPFLG_OS_ONLY & flags)) {
+	char *end;
+	ErtsFreeSegDesc *desc;
+	Uint32 superaligned = (ERTS_MMAPFLG_SUPERALIGNED & flags);
+
+	erts_smp_mtx_lock(&mmap_state.mtx);
+
+	if (!superaligned) {
+	    desc = lookup_free_seg(&mmap_state.sua.map, asize);
+	    if (desc) {
+		seg = desc->start;
+		end = seg+asize;
+		if (!mmap_state.reserve_physical(seg, asize))
+		    goto supercarrier_reserve_failure;
+		if (desc->end == end) {
+		    delete_free_seg(&mmap_state.sua.map, desc);
+		    free_desc(desc);
+		}
+		else {
+		    ERTS_MMAP_ASSERT(end < desc->end);
+		    resize_free_seg(&mmap_state.sua.map, desc, end, desc->end);
+		}
+		ERTS_MMAP_SIZE_SC_SUA_INC(asize);
+		goto supercarrier_success;
+	    }
+
+	    if (asize <= mmap_state.sua.bot - mmap_state.sa.top) {
+		if (!mmap_state.reserve_physical(mmap_state.sua.bot - asize,
+						 asize))
+		    goto supercarrier_reserve_failure;
+		mmap_state.sua.bot -= asize;
+		seg = mmap_state.sua.bot;
+		ERTS_MMAP_SIZE_SC_SUA_INC(asize);
+		goto supercarrier_success;
+	    }
+	}
+
+	asize = ERTS_SUPERALIGNED_CEILING(asize);
+
+	desc = lookup_free_seg(&mmap_state.sa.map, asize);
+	if (desc) {
+	    seg = desc->start;
+	    end = seg+asize;
+	    if (!mmap_state.reserve_physical(seg, asize))
+		goto supercarrier_reserve_failure;
+	    if (desc->end == end) {
+		delete_free_seg(&mmap_state.sa.map, desc);
+		free_desc(desc);
+	    }
+	    else {
+		ERTS_MMAP_ASSERT(end < desc->end);
+		resize_free_seg(&mmap_state.sa.map, desc, end, desc->end);
+	    }
+	    ERTS_MMAP_SIZE_SC_SA_INC(asize);
+	    goto supercarrier_success;
+	}
+
+	if (superaligned) {
+
+	    if (asize <= mmap_state.sua.bot - mmap_state.sa.top) {
+		seg = (void *) mmap_state.sa.top;
+		if (!mmap_state.reserve_physical(seg, asize))
+		    goto supercarrier_reserve_failure;
+		mmap_state.sa.top += asize;
+		ERTS_MMAP_SIZE_SC_SA_INC(asize);
+		goto supercarrier_success;
+	    }
+
+	    desc = lookup_free_seg(&mmap_state.sua.map, asize + ERTS_SUPERALIGNED_SIZE);
+	    if (desc) {
+		char *org_start = desc->start;
+		char *org_end = desc->end;
+
+		seg = (char *) ERTS_SUPERALIGNED_CEILING(org_start);
+		end = seg + asize;
+		if (!mmap_state.reserve_physical(seg, asize))
+		    goto supercarrier_reserve_failure;
+		if (org_start != seg) {
+		    ERTS_MMAP_ASSERT(org_start < seg);
+		    resize_free_seg(&mmap_state.sua.map, desc, org_start, seg);
+		    desc = NULL;
+		}
+		if (end != org_end) {
+		    ERTS_MMAP_ASSERT(end < org_end);
+		    if (desc)
+			resize_free_seg(&mmap_state.sua.map, desc, end, org_end);
+		    else {
+			desc = alloc_desc();
+			if (!desc)
+			    add_free_desc_area(end, org_end);
+			else
+			    insert_free_seg(&mmap_state.sua.map, desc, end, org_end);
+		    }
+		}
+		ERTS_MMAP_SIZE_SC_SA_INC(asize);
+		goto supercarrier_success;
+	    }
+	}
+
+	erts_smp_mtx_unlock(&mmap_state.mtx);
+    }
+
+#if ERTS_HAVE_OS_MMAP
+    /* Map using OS primitives */
+    if (!(ERTS_MMAPFLG_SUPERCARRIER_ONLY & flags) && !mmap_state.no_os_mmap) {
+	if (!(ERTS_MMAPFLG_SUPERALIGNED & flags)) {
+	    seg = os_mmap(asize, 0);
+	    if (!seg)
+		return NULL;
+	}
+	else {
+	    asize = ERTS_SUPERALIGNED_CEILING(*sizep);
+	    seg = os_mmap(asize, 1);
+	    if (!seg)
+		return NULL;
+
+	    if (!ERTS_IS_SUPERALIGNED(seg)) {
+		char *ptr;
+		UWord sz;
+
+		os_munmap(seg, asize);
+
+		ptr = os_mmap(asize + ERTS_SUPERALIGNED_SIZE, 1);
+		if (!ptr)
+		    return NULL;
+
+		seg = (char *) ERTS_SUPERALIGNED_CEILING(ptr);
+		sz = (UWord) (seg - ptr);
+		ERTS_MMAP_ASSERT(sz <= ERTS_SUPERALIGNED_SIZE);
+		if (sz)
+		    os_munmap(ptr, sz);
+		sz = ERTS_SUPERALIGNED_SIZE - sz; 
+		if (sz)
+		    os_munmap(seg+asize, sz);
+	    }
+	}
+
+	ERTS_MMAP_SIZE_OS_INC(asize);
+	*sizep = asize;
+	return (void *) seg;
+    }
+#endif
+    *sizep = 0;
+    return NULL;
+
+supercarrier_success:
+
+#ifdef ERTS_MMAP_DEBUG
+    if ((ERTS_MMAPFLG_SUPERALIGNED & flags)
+	|| ERTS_MMAP_IN_SUPERALIGNED_AREA(seg)) {
+	ERTS_MMAP_ASSERT(ERTS_IS_SUPERALIGNED(seg));
+	ERTS_MMAP_ASSERT(ERTS_IS_SUPERALIGNED(asize));
+    }
+    else {
+	ERTS_MMAP_ASSERT(ERTS_IS_PAGEALIGNED(seg));
+	ERTS_MMAP_ASSERT(ERTS_IS_PAGEALIGNED(asize));
+    }
+#endif
+
+    erts_smp_mtx_unlock(&mmap_state.mtx);
+
+    *sizep = asize;
+    return (void *) seg;
+
+supercarrier_reserve_failure:
+    erts_smp_mtx_unlock(&mmap_state.mtx);
+
+    *sizep = 0;
+    return NULL;
+
+}
+
+void
+erts_munmap(Uint32 flags, void **ptrp, UWord *sizep)
+{
+    void *ptr = *ptrp;
+    UWord size = *sizep;
+    ERTS_MMAP_ASSERT(ERTS_IS_PAGEALIGNED(ptr));
+    ERTS_MMAP_ASSERT(ERTS_IS_PAGEALIGNED(size));
+    if (!ERTS_MMAP_IN_SUPERCARRIER(ptr)) {
+	ERTS_MMAP_ASSERT(!mmap_state.no_os_mmap);
+#if ERTS_HAVE_OS_MMAP
+	ERTS_MMAP_SIZE_OS_DEC(size);
+	os_munmap(ptr, size);
+#endif
+    }
+    else {
+	char *start, *end;
+	ErtsFreeSegMap *map;
+	ErtsFreeSegDesc *prev, *next, *desc;
+
+	ERTS_MMAP_ASSERT(mmap_state.supercarrier);
+
+	start = (char *) ptr;
+	end = start + size;
+
+	erts_smp_mtx_lock(&mmap_state.mtx);
+
+	if (ERTS_MMAP_IN_SUPERALIGNED_AREA(ptr)) {
+
+	    start = (char *) ERTS_SUPERALIGNED_CEILING(start);
+	    end = (char *) ERTS_SUPERALIGNED_FLOOR(end);
+
+	    size = (UWord) (end - start);
+	    *ptrp = start;
+	    *sizep = size;
+
+	    map = &mmap_state.sa.map;
+	    adjacent_free_seg(map, start, end, &prev, &next);
+
+	    ERTS_MMAP_SIZE_SC_SA_DEC(size);
+	    if (end == mmap_state.sa.top) {
+		ERTS_MMAP_ASSERT(!next);
+		if (prev) {
+		    start = prev->start;
+		    delete_free_seg(map, prev);
+		    free_desc(prev);
+		}
+		mmap_state.sa.top = start;
+		goto supercarrier_success;
+	    }
+	}
+	else {
+	    ERTS_MMAP_ASSERT(ERTS_MMAP_IN_SUPERUNALIGNED_AREA(ptr));
+
+	    map = &mmap_state.sua.map;
+	    adjacent_free_seg(map, start, end, &prev, &next);
+
+	    ERTS_MMAP_SIZE_SC_SUA_DEC(size);
+	    if (start == mmap_state.sua.bot) {
+		ERTS_MMAP_ASSERT(!prev);
+		if (next) {
+		    end = next->end;
+		    delete_free_seg(map, next);
+		    free_desc(next);
+		}
+		mmap_state.sua.bot = end;
+		goto supercarrier_success;
+	    }
+	}
+
+	desc = NULL;
+
+	if (next) {
+	    ERTS_MMAP_ASSERT(end < next->end);
+	    end = next->end;
+	    if (prev) {
+		delete_free_seg(map, next);
+		free_desc(next);
+		goto save_prev;
+	    }
+	    desc = next;
+	} else if (prev) {
+	save_prev:
+	    ERTS_MMAP_ASSERT(prev->start < start);
+	    start = prev->start;
+	    desc = prev;
+	}
+
+	if (desc)
+	    resize_free_seg(map, desc, start, end);
+	else {
+	    desc = alloc_desc();
+	    if (desc)
+		insert_free_seg(map, desc, start, end);
+	    else {
+		if (map == &mmap_state.sa.map)
+		    ERTS_MMAP_SIZE_SC_SA_INC(size);
+		else
+		    ERTS_MMAP_SIZE_SC_SUA_INC(size);
+		add_free_desc_area(start, end);
+	    }
+	}
+
+    supercarrier_success:
+	erts_smp_mtx_unlock(&mmap_state.mtx);
+
+	mmap_state.unreserve_physical((char *) ptr, size);
+    }
+}
+
+static void *
+remap_move(Uint32 flags, void *ptr, UWord old_size, UWord *sizep)
+{
+    UWord size = *sizep;
+    UWord um_size = old_size;
+    void *um_ptr = ptr;
+    void *new_ptr = erts_mmap(flags, &size);
+    if (!new_ptr)
+	return NULL;
+    *sizep = size;
+    if (old_size < size)
+	size = old_size;
+    sys_memcpy(new_ptr, ptr, (size_t) size);
+    erts_munmap(flags, &um_ptr, &um_size);
+    ERTS_MMAP_ASSERT(um_ptr == ptr);
+    ERTS_MMAP_ASSERT(um_size == old_size);
+    return new_ptr;
+}
+
+void *
+erts_mremap(Uint32 flags, void *ptr, UWord old_size, UWord *sizep)
+{
+    void *new_ptr;
+    Uint32 superaligned;
+    UWord asize;
+
+    ERTS_MMAP_ASSERT(ERTS_IS_PAGEALIGNED(ptr));
+    ERTS_MMAP_ASSERT(ERTS_IS_PAGEALIGNED(old_size));
+    ERTS_MMAP_ASSERT(sizep && ERTS_IS_PAGEALIGNED(*sizep));
+
+    if (!ERTS_MMAP_IN_SUPERCARRIER(ptr)) {
+
+	ERTS_MMAP_ASSERT(!mmap_state.no_os_mmap);
+
+	if (!(ERTS_MMAPFLG_OS_ONLY & flags) && mmap_state.supercarrier) {
+	    new_ptr = remap_move(ERTS_MMAPFLG_SUPERCARRIER_ONLY|flags, ptr,
+				 old_size, sizep);
+	    if (new_ptr)
+		return new_ptr;
+	}
+
+	if (ERTS_MMAPFLG_SUPERCARRIER_ONLY & flags)
+	    return NULL;
+
+#if ERTS_HAVE_OS_MREMAP || ERTS_HAVE_GENUINE_OS_MMAP
+	superaligned = (ERTS_MMAPFLG_SUPERALIGNED & flags);
+
+	if (superaligned) {
+	    asize = ERTS_SUPERALIGNED_CEILING(*sizep);
+	    if (asize == old_size && ERTS_IS_SUPERALIGNED(ptr)) {
+		*sizep = asize;
+		return ptr;
+	    }
+	}
+	else {
+	    asize = ERTS_PAGEALIGNED_CEILING(*sizep);
+	    if (asize == old_size) {
+		*sizep = asize;
+		return ptr;
+	    }
+	}
+
+#if ERTS_HAVE_GENUINE_OS_MMAP
+	if (asize < old_size
+	    && (!superaligned
+		|| ERTS_IS_SUPERALIGNED(ptr))) {
+	    UWord um_sz;
+	    new_ptr = ((char *) ptr) + asize;
+	    ERTS_MMAP_ASSERT((((char *)ptr) + old_size) > (char *) new_ptr);
+	    um_sz = (UWord) ((((char *) ptr) + old_size) - (char *) new_ptr); 
+	    ERTS_MMAP_SIZE_OS_DEC(um_sz);
+	    os_munmap(new_ptr, um_sz);
+	    *sizep = asize;
+	    return ptr;
+	}
+#endif
+#if ERTS_HAVE_OS_MREMAP
+	if (superaligned)
+	    return remap_move(flags, new_ptr, old_size, sizep);
+	else {
+	    new_ptr = os_mremap(ptr, old_size, asize, 0);
+	    if (!new_ptr)
+		return NULL;
+	    if (asize > old_size)
+		ERTS_MMAP_SIZE_OS_INC(asize - old_size);
+	    else
+		ERTS_MMAP_SIZE_OS_DEC(old_size - asize);
+	    *sizep = asize;
+	    return new_ptr;
+	}
+#endif
+#endif
+    }
+    else { /* In super carrier */
+	char *start, *end, *new_end;
+	ErtsFreeSegMap *map;
+	ErtsFreeSegDesc *prev, *next, *desc;
+
+	ERTS_MMAP_ASSERT(mmap_state.supercarrier);
+
+	if (ERTS_MMAPFLG_OS_ONLY & flags)
+	    return remap_move(flags, ptr, old_size, sizep);
+
+	superaligned = (ERTS_MMAPFLG_SUPERALIGNED & flags);
+
+	asize = (superaligned
+		 ? ERTS_SUPERALIGNED_CEILING(*sizep)
+		 : ERTS_PAGEALIGNED_CEILING(*sizep));
+
+	erts_smp_mtx_lock(&mmap_state.mtx);
+
+	if (ERTS_MMAP_IN_SUPERALIGNED_AREA(ptr)
+	    ? (!superaligned && lookup_free_seg(&mmap_state.sua.map, asize))
+	    : (superaligned && lookup_free_seg(&mmap_state.sa.map, asize))) {
+	    erts_smp_mtx_unlock(&mmap_state.mtx);
+	    /*
+	     * Segment currently in wrong area (due to a previous memory
+	     * shortage), move it to the right area.
+	     * (remap_move() will succeed)
+	     */
+	    return remap_move(ERTS_MMAPFLG_SUPERCARRIER_ONLY|flags, ptr,
+			      old_size, sizep);
+	}
+
+	if (asize == old_size) {
+	    new_ptr = ptr;
+	    goto supercarrier_resize_success;
+	}
+
+	start = (char *) ptr;
+	end = start + old_size;
+	new_end = start+asize;
+
+	if (asize < old_size) {
+	    new_ptr = ptr;
+	    if (!ERTS_MMAP_IN_SUPERALIGNED_AREA(ptr)) {
+		ERTS_MMAP_ASSERT(ERTS_IS_PAGEALIGNED(ptr));
+		ERTS_MMAP_ASSERT(ERTS_IS_PAGEALIGNED(old_size));
+		ERTS_MMAP_ASSERT(ERTS_IS_PAGEALIGNED(asize));
+		map = &mmap_state.sua.map;
+		ERTS_MMAP_SIZE_SC_SUA_DEC(old_size - asize);
+	    }
+	    else {
+		ERTS_MMAP_ASSERT(ERTS_IS_SUPERALIGNED(ptr));
+		ERTS_MMAP_ASSERT(ERTS_IS_SUPERALIGNED(old_size));
+		if (!superaligned) {
+		    /* must be a superaligned size in this area */
+		    asize = ERTS_SUPERALIGNED_CEILING(asize);
+		    ERTS_MMAP_ASSERT(asize <= old_size);
+		    if (asize == old_size)
+			goto supercarrier_resize_success;
+		    new_end = start+asize;
+		}
+		ERTS_MMAP_ASSERT(ERTS_IS_SUPERALIGNED(asize));
+		if (end == mmap_state.sa.top) {
+		    mmap_state.sa.top = new_end;
+		    mmap_state.unreserve_physical(((char *) ptr) + asize,
+						  old_size - asize);
+		    goto supercarrier_resize_success;
+		}
+		ERTS_MMAP_SIZE_SC_SA_DEC(old_size - asize);
+		map = &mmap_state.sa.map;
+	    }
+	    
+	    adjacent_free_seg(map, start, end, &prev, &next);
+
+	    if (next)
+		resize_free_seg(map, next, new_end, next->end);
+	    else {
+		desc = alloc_desc();
+		if (desc)
+		    insert_free_seg(map, desc, new_end, end);
+		else {
+		    if (map == &mmap_state.sa.map)
+			ERTS_MMAP_SIZE_SC_SA_INC(old_size - asize);
+		    else
+			ERTS_MMAP_SIZE_SC_SUA_INC(old_size - asize);
+		    add_free_desc_area(new_end, end);
+		    goto supercarrier_resize_success;
+		}
+	    }
+	    mmap_state.unreserve_physical(((char *) ptr) + asize,
+					  old_size - asize);
+	    goto supercarrier_resize_success;
+	}
+
+	if (!ERTS_MMAP_IN_SUPERALIGNED_AREA(ptr)) {
+	    ERTS_MMAP_ASSERT(ERTS_IS_PAGEALIGNED(ptr));
+	    ERTS_MMAP_ASSERT(ERTS_IS_PAGEALIGNED(old_size));
+	    ERTS_MMAP_ASSERT(ERTS_IS_PAGEALIGNED(asize));
+
+	    adjacent_free_seg(&mmap_state.sua.map, start, end, &prev, &next);
+
+	    if (next && new_end <= next->end) {
+		if (!mmap_state.reserve_physical(((char *) ptr) + old_size,
+						 asize - old_size))
+		    goto supercarrier_reserve_failure;
+		if (new_end < next->end)
+		    resize_free_seg(&mmap_state.sua.map, next, new_end, next->end);
+		else {
+		    delete_free_seg(&mmap_state.sua.map, next);
+		    free_desc(next);
+		}
+		new_ptr = ptr;
+		ERTS_MMAP_SIZE_SC_SUA_INC(asize - old_size);
+		goto supercarrier_resize_success;
+	    }
+	}
+	else { /* Superaligned area */
+	    ERTS_MMAP_ASSERT(ERTS_IS_SUPERALIGNED(ptr));
+	    ERTS_MMAP_ASSERT(ERTS_IS_SUPERALIGNED(old_size));
+
+	    if (!superaligned) {
+		/* must be a superaligned size in this area */
+		asize = ERTS_PAGEALIGNED_CEILING(asize);
+		new_end = start+asize;
+	    }
+
+	    ERTS_MMAP_ASSERT(ERTS_IS_SUPERALIGNED(asize));
+
+	    if (end == mmap_state.sa.top) {
+		if (new_end <= mmap_state.sua.bot) {
+		    if (!mmap_state.reserve_physical(((char *) ptr) + old_size,
+						     asize - old_size))
+			goto supercarrier_reserve_failure;
+		    mmap_state.sa.top = new_end;
+		    new_ptr = ptr;
+		    ERTS_MMAP_SIZE_SC_SA_INC(asize - old_size);
+		    goto supercarrier_resize_success;
+		}
+	    }
+	    else {
+		adjacent_free_seg(&mmap_state.sa.map, start, end, &prev, &next);
+		if (next && new_end <= next->end) {
+		    if (!mmap_state.reserve_physical(((char *) ptr) + old_size,
+						     asize - old_size))
+			goto supercarrier_reserve_failure;
+		    if (new_end < next->end)
+			resize_free_seg(&mmap_state.sa.map, next, new_end, next->end);
+		    else {
+			delete_free_seg(&mmap_state.sa.map, next);
+			free_desc(next);
+		    }
+		    new_ptr = ptr;
+		    ERTS_MMAP_SIZE_SC_SA_INC(asize - old_size);
+		    goto supercarrier_resize_success;
+		}
+	    }
+	}
+	erts_smp_mtx_unlock(&mmap_state.mtx);
+
+	/* Failed to resize... */
+    }
+
+    return remap_move(flags, ptr, old_size, sizep);
+
+supercarrier_resize_success:
+
+#ifdef ERTS_MMAP_DEBUG
+    if ((ERTS_MMAPFLG_SUPERALIGNED & flags)
+	|| ERTS_MMAP_IN_SUPERALIGNED_AREA(new_ptr)) {
+	ERTS_MMAP_ASSERT(ERTS_IS_SUPERALIGNED(new_ptr));
+	ERTS_MMAP_ASSERT(ERTS_IS_SUPERALIGNED(asize));
+    }
+    else {
+	ERTS_MMAP_ASSERT(ERTS_IS_PAGEALIGNED(new_ptr));
+	ERTS_MMAP_ASSERT(ERTS_IS_PAGEALIGNED(asize));
+    }
+#endif
+
+    erts_smp_mtx_unlock(&mmap_state.mtx);
+
+    *sizep = asize;
+    return new_ptr;
+
+supercarrier_reserve_failure:
+
+    erts_smp_mtx_unlock(&mmap_state.mtx);
+    *sizep = 0;
+    return NULL;
+    
+}
+
+int erts_mmap_in_supercarrier(void *ptr)
+{
+    return ERTS_MMAP_IN_SUPERCARRIER(ptr);
+}
+
+void
+erts_mmap_init(ErtsMMapInit *init)
+{
+    int virtual_map = 0;
+    char *start = NULL, *end = NULL;
+    UWord pagesize;
+#if defined(__WIN32__)
+    SYSTEM_INFO sysinfo;
+    GetSystemInfo(&sysinfo);
+    pagesize = (UWord) sysinfo.dwPageSize;
+#elif defined(_SC_PAGESIZE)
+    pagesize = (UWord) sysconf(_SC_PAGESIZE);
+#elif defined(HAVE_GETPAGESIZE)
+    pagesize = (UWord) getpagesize();
+#else
+#  error "Do not know how to get page size"
+#endif
+#if defined(HARD_DEBUG)  || 0
+    erts_fprintf(stderr, "erts_mmap: scs = %bpu\n", init->scs);
+    erts_fprintf(stderr, "erts_mmap: sco = %i\n", init->sco);
+    erts_fprintf(stderr, "erts_mmap: scmgc = %i\n", init->scmgc);
+#endif
+    erts_page_inv_mask = pagesize - 1;
+    if (pagesize & erts_page_inv_mask)
+	erl_exit(-1, "erts_mmap: Invalid pagesize: %bpu\n",
+		 pagesize);
+
+    erts_have_erts_mmap = 0;
+
+    mmap_state.reserve_physical = reserve_noop;
+    mmap_state.unreserve_physical = unreserve_noop;
+
+#if HAVE_MMAP && !defined(MAP_ANON)
+    mmap_state.mmap_fd = open("/dev/zero", O_RDWR);
+    if (mmap_state.mmap_fd < 0)
+	erl_exit(-1, "erts_mmap: Failed to open /dev/zero\n");
+#endif
+
+    erts_smp_mtx_init(&mmap_state.mtx, "erts_mmap");
+
+#ifdef ERTS_HAVE_OS_PHYSICAL_MEMORY_RESERVATION
+    if (init->virtual_range.start) {
+	char *ptr;
+	UWord sz;
+	ptr = (char *) ERTS_PAGEALIGNED_CEILING(init->virtual_range.start);
+	end = (char *) ERTS_PAGEALIGNED_FLOOR(init->virtual_range.end);
+	sz = end - ptr;
+	start = os_mmap_virtual(ptr, sz);
+	if (!start || start > ptr || start >= end)
+	    erl_exit(-1,
+		     "erts_mmap: Failed to create virtual range for super carrier\n");
+	sz = start - ptr;
+	if (sz)
+	    os_munmap(end, sz);
+	mmap_state.reserve_physical = os_reserve_physical;
+	mmap_state.unreserve_physical = os_unreserve_physical;
+	virtual_map = 1;
+    }
+    else
+#endif
+	if (init->predefined_area.start) {
+	    start = init->predefined_area.start;
+	    end = init->predefined_area.end;
+	    if (end != (void *) 0 && end < start)
+		end = start;
+    }
+#if ERTS_HAVE_OS_MMAP
+    else if (init->scs) {
+	UWord sz;
+	sz = ERTS_PAGEALIGNED_CEILING(init->scs);
+#ifdef ERTS_HAVE_OS_PHYSICAL_MEMORY_RESERVATION
+	if (!init->scrpm) {
+	    start = os_mmap_virtual(NULL, sz);
+	    mmap_state.reserve_physical = os_reserve_physical;
+	    mmap_state.unreserve_physical = os_unreserve_physical;
+	    virtual_map = 1;
+	}
+	else
+#endif
+	{
+	    /*
+	     * The whole supercarrier will by physically
+	     * reserved all the time.
+	     */
+	    start = os_mmap(sz, 1);
+	}
+	if (!start)
+	    erl_exit(-1,
+		     "erts_mmap: Failed to create super carrier of size %bpu MB\n",
+		     init->scs/1024/1024);
+	end = start + sz;
+#ifdef ERTS_MMAP_DEBUG_FILL_AREAS
+	if (!virtual_map) {
+	    Uint32 *uip;
+
+	    for (uip = (Uint32 *) start; uip < (Uint32 *) end; uip++)
+		*uip = (Uint32) 0xdeadbeef;
+	}
+#endif
+    }
+    if (!mmap_state.no_os_mmap)
+	erts_have_erts_mmap |= ERTS_HAVE_ERTS_OS_MMAP;
+#endif
+
+    mmap_state.size.supercarrier.total = 0;
+    mmap_state.size.supercarrier.used.total = 0;
+    mmap_state.size.supercarrier.used.sa = 0;
+    mmap_state.size.supercarrier.used.sua = 0;
+    mmap_state.size.os.used = 0;
+
+    if (!start) {
+	mmap_state.sa.bot = NULL;
+	mmap_state.sua.top = NULL;
+	mmap_state.sa.bot = NULL;
+	mmap_state.sua.top = NULL;
+	mmap_state.no_os_mmap = 0;
+    }
+    else {
+	size_t desc_size;
+
+	mmap_state.no_os_mmap = init->sco;
+
+	desc_size = init->scmgc;
+	if (desc_size < 100)
+	    desc_size = 100;
+	desc_size *= sizeof(ErtsFreeSegDesc);
+	if ((desc_size
+	     + ERTS_SUPERALIGNED_SIZE
+	     + ERTS_PAGEALIGNED_SIZE) > end - start)
+	    erl_exit(-1, "erts_mmap: No space for segments in super carrier\n");
+
+	mmap_state.sa.bot = start;
+	mmap_state.sa.bot += desc_size;
+	mmap_state.sa.bot = (char *) ERTS_SUPERALIGNED_CEILING(mmap_state.sa.bot);
+	mmap_state.sa.top = mmap_state.sa.bot;
+	mmap_state.sua.top = (char *) ERTS_SUPERALIGNED_FLOOR(end);
+	mmap_state.sua.bot = mmap_state.sua.top;
+
+	mmap_state.size.os.used += (UWord) (mmap_state.sa.bot - start);
+
+	if (end == (void *) 0) {
+	    /*
+	     * Very unlikely, but we need a guarantee
+	     * that `mmap_state.sua.top` always will
+	     * compare as larger than all segment pointers
+	     * into the super carrier...
+	     */
+	    mmap_state.sua.top -= ERTS_PAGEALIGNED_SIZE;
+	    mmap_state.size.os.used += ERTS_PAGEALIGNED_SIZE;
+	}
+
+	mmap_state.size.supercarrier.total = (UWord) (mmap_state.sua.top - mmap_state.sa.bot);
+
+	/*
+	 * Area before (and after) super carrier
+	 * will be used for free segment descritors.
+	 */
+	mmap_state.desc_free_list = NULL;
+#ifdef ERTS_HAVE_OS_PHYSICAL_MEMORY_RESERVATION
+	if (virtual_map && mmap_state.sa.bot - start > 0)
+	    os_reserve_physical(start, mmap_state.sa.bot - start);
+#endif
+	add_free_desc_area(start, mmap_state.sa.bot);
+#ifdef ERTS_HAVE_OS_PHYSICAL_MEMORY_RESERVATION
+	if (virtual_map && end - mmap_state.sua.top > 0)
+	    os_reserve_physical(mmap_state.sua.top, end - mmap_state.sua.top);
+#endif
+	add_free_desc_area(mmap_state.sua.top, end);
+
+	init_free_seg_map(&mmap_state.sa.map, 0);
+	init_free_seg_map(&mmap_state.sua.map, 1);
+
+	mmap_state.supercarrier = 1;
+	erts_have_erts_mmap |= ERTS_HAVE_ERTS_SUPERCARRIER_MMAP;
+
 
+#ifdef HARD_DEBUG
     {
         void test_it(void);
         test_it();
     }
 #endif
+
+    }
+#if !ERTS_HAVE_OS_MMAP
+    mmap_state.no_os_mmap = 1;
+#endif
+
 }
 
 
@@ -897,12 +1973,6 @@ print_tree(enum SortOrder order, RBTNode* root)
 
 #endif /* PRINT_TREE */
 
-
-static ErtsFreeSegDesc* new_desc(void)
-{
-    return (ErtsFreeSegDesc*) malloc(sizeof(ErtsFreeSegDesc));
-}
-
 void test_it(void)
 {
     ErtsFreeSegMap map;
@@ -912,13 +1982,13 @@ void test_it(void)
     for (i=0; i<2; i++) {
         init_free_seg_map(&map, i);
 
-        insert_free_seg(&map, new_desc(), (char*)0x11000, (char*)0x12000);
+        insert_free_seg(&map, alloc_desc(), (char*)0x11000, (char*)0x12000);
         check_tree(&map.atree, 0); check_tree(&map.stree, 0);
-        insert_free_seg(&map, new_desc(), (char*)0x13000, (char*)0x14000);
+        insert_free_seg(&map, alloc_desc(), (char*)0x13000, (char*)0x14000);
         check_tree(&map.atree, 0); check_tree(&map.stree, 0);
-        insert_free_seg(&map, new_desc(), (char*)0x15000, (char*)0x17000);
+        insert_free_seg(&map, alloc_desc(), (char*)0x15000, (char*)0x17000);
         check_tree(&map.atree, 0); check_tree(&map.stree, 0);
-        insert_free_seg(&map, new_desc(), (char*)0x8000, (char*)0x10000);
+        insert_free_seg(&map, alloc_desc(), (char*)0x8000, (char*)0x10000);
         check_tree(&map.atree, 0); check_tree(&map.stree, 0);
 
         desc = lookup_free_seg(&map, 0x500);
diff --git a/erts/emulator/sys/common/erl_mmap.h b/erts/emulator/sys/common/erl_mmap.h
index 64baa6c493..143f1aff3e 100644
--- a/erts/emulator/sys/common/erl_mmap.h
+++ b/erts/emulator/sys/common/erl_mmap.h
@@ -1,7 +1,7 @@
 /*
  * %CopyrightBegin%
  *
- * Copyright Ericsson AB 2002-2013. All Rights Reserved.
+ * 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
@@ -17,10 +17,95 @@
  * %CopyrightEnd%
  */
 
+#ifndef ERL_MMAP_H__
+#define ERL_MMAP_H__
+
+#include "sys.h"
+
+#define ERTS_MMAP_SUPERALIGNED_BITS (18)
+/* Affects hard limits for sbct and lmbcs documented in erts_alloc.xml */
+
+#define ERTS_MMAPFLG_OS_ONLY			(((Uint32) 1) << 0)
+#define ERTS_MMAPFLG_SUPERCARRIER_ONLY		(((Uint32) 1) << 1)
+#define ERTS_MMAPFLG_SUPERALIGNED		(((Uint32) 1) << 2)
+
+#define ERTS_HAVE_ERTS_OS_MMAP			(1 << 0)
+#define ERTS_HAVE_ERTS_SUPERCARRIER_MMAP	(1 << 1)
+extern int erts_have_erts_mmap;
+extern UWord erts_page_inv_mask;
+
 typedef struct {
-    SWord scs;  /* super carrier size */
+    struct {
+	char *start;
+	char *end;
+    } virtual_range;
+    struct {
+	char *start;
+	char *end;
+    } predefined_area;
+    UWord scs;  /* super carrier size */
     int sco;    /* super carrier only? */
     Uint scmgc; /* super carrier: max guaranteed (number of) carriers */
+    int scrpm;
 }ErtsMMapInit;
 
+#define ERTS_MMAP_INIT_DEFAULT_INITER \
+    {{NULL, NULL}, {NULL, NULL}, 0, 1, (1 << 16), 1}
+
+void *erts_mmap(Uint32 flags, UWord *sizep);
+void erts_munmap(Uint32 flags, void **ptrp, UWord *sizep);
+void *erts_mremap(Uint32 flags, void *ptr, UWord old_size, UWord *sizep);
+int erts_mmap_in_supercarrier(void *ptr);
 void erts_mmap_init(ErtsMMapInit*);
+
+#define ERTS_SUPERALIGNED_SIZE \
+    (1 << ERTS_MMAP_SUPERALIGNED_BITS)
+#define ERTS_INV_SUPERALIGNED_MASK \
+    ((UWord) (ERTS_SUPERALIGNED_SIZE - 1))
+#define ERTS_SUPERALIGNED_MASK \
+    (~ERTS_INV_SUPERALIGNED_MASK)
+#define ERTS_SUPERALIGNED_FLOOR(X) \
+    (((UWord) (X)) & ERTS_SUPERALIGNED_MASK)
+#define ERTS_SUPERALIGNED_CEILING(X) \
+    ERTS_SUPERALIGNED_FLOOR((X) + ERTS_INV_SUPERALIGNED_MASK)
+#define ERTS_IS_SUPERALIGNED(X) \
+    (((UWord) (X) & ERTS_INV_SUPERALIGNED_MASK) == 0)
+
+#define ERTS_INV_PAGEALIGNED_MASK \
+    (erts_page_inv_mask)
+#define ERTS_PAGEALIGNED_MASK \
+    (~ERTS_INV_PAGEALIGNED_MASK)
+#define ERTS_PAGEALIGNED_FLOOR(X) \
+    (((UWord) (X)) & ERTS_PAGEALIGNED_MASK)
+#define ERTS_PAGEALIGNED_CEILING(X) \
+    ERTS_PAGEALIGNED_FLOOR((X) + ERTS_INV_PAGEALIGNED_MASK)
+#define ERTS_IS_PAGEALIGNED(X) \
+    (((UWord) (X) & ERTS_INV_PAGEALIGNED_MASK) == 0)
+#define ERTS_PAGEALIGNED_SIZE \
+    (ERTS_INV_PAGEALIGNED_MASK + 1)
+
+#ifndef HAVE_MMAP
+#  define HAVE_MMAP 0
+#endif
+#ifndef HAVE_MREMAP
+#  define HAVE_MREMAP 0
+#endif
+#if HAVE_MMAP
+#  define ERTS_HAVE_OS_MMAP 1
+#  define ERTS_HAVE_GENUINE_OS_MMAP 1
+#  if HAVE_MREMAP
+#    define ERTS_HAVE_OS_MREMAP 1
+#  endif
+#  if defined(MAP_FIXED) && defined(MAP_NORESERVE)
+#    define ERTS_HAVE_OS_PHYSICAL_MEMORY_RESERVATION 1
+#  endif
+#endif
+
+#ifndef HAVE_VIRTUALALLOC
+#  define HAVE_VIRTUALALLOC 0
+#endif
+#if HAVE_VIRTUALALLOC
+#  define ERTS_HAVE_OS_MMAP 1
+#endif
+
+#endif /* ERL_MMAP_H__ */
diff --git a/erts/emulator/sys/common/erl_mseg.c b/erts/emulator/sys/common/erl_mseg.c
index 64fcb6bb40..b21d6ca393 100644
--- a/erts/emulator/sys/common/erl_mseg.c
+++ b/erts/emulator/sys/common/erl_mseg.c
@@ -100,45 +100,6 @@ static int atoms_initialized;
 
 typedef struct mem_kind_t MemKind;
 
-#if HALFWORD_HEAP
-static int initialize_pmmap(void);
-static void *pmmap(size_t size);
-static int pmunmap(void *p, size_t size);
-static void *pmremap(void *old_address, size_t old_size,
-		     size_t new_size);
-#endif
-
-#if HAVE_MMAP
-/* Mmap ... */
-
-#define MMAP_PROT		(PROT_READ|PROT_WRITE)
-
-
-#ifdef MAP_ANON
-#  define MMAP_FLAGS		(MAP_ANON|MAP_PRIVATE)
-#  define MMAP_FD		(-1)
-#else
-#  define MMAP_FLAGS		(MAP_PRIVATE)
-#  define MMAP_FD		mmap_fd
-static int mmap_fd;
-#endif
-
-#if HAVE_MREMAP
-#  define HAVE_MSEG_RECREATE 1
-#else
-#  define HAVE_MSEG_RECREATE 0
-#endif
-
-#if HALFWORD_HEAP
-#define CAN_PARTLY_DESTROY 0
-#else
-#define CAN_PARTLY_DESTROY 1
-#endif
-#else  /* #if HAVE_MMAP */
-#define CAN_PARTLY_DESTROY 0
-#error "Not supported"
-#endif /* #if HAVE_MMAP */
-
 const ErtsMsegOpt_t erts_mseg_default_opt = {
     1,			/* Use cache		     */
     1,			/* Preserv data		     */
@@ -163,9 +124,7 @@ typedef struct {
     CallCounter create;
     CallCounter create_resize;
     CallCounter destroy;
-#if HAVE_MSEG_RECREATE
     CallCounter recreate;
-#endif
     CallCounter clear_cache;
     CallCounter check_cache;
 } ErtsMsegCalls;
@@ -236,11 +195,6 @@ struct ErtsMsegAllctr_t_ {
     Uint rel_max_cache_bad_fit;
 
     ErtsMsegCalls calls;
-
-#if CAN_PARTLY_DESTROY
-    Uint min_seg_size;
-#endif
-
 };
 
 typedef union {
@@ -344,69 +298,31 @@ schedule_cache_check(ErtsMsegAllctr_t *ma) {
     }
 }
 
-/* remove ErtsMsegAllctr_t from arguments?
- * only used for statistics
- */
-static ERTS_INLINE void *
-mmap_align(ErtsMsegAllctr_t *ma, void *addr, size_t length, int prot, int flags, int fd, off_t offset) {
-
-    char *p, *q;
-    UWord d;
-
-    p = mmap(addr, length, prot, flags, fd, offset);
-
-    if (MAP_IS_ALIGNED(p) || p == MAP_FAILED)
-	return p;
-
-    if (ma)
-	INC_CC(ma, create_resize);
-
-    munmap(p, length);
-
-    if ((p = mmap(addr, length + MSEG_ALIGNED_SIZE, prot, flags, fd, offset)) == MAP_FAILED)
-	return MAP_FAILED;
-
-    q = (void *)ALIGNED_CEILING((char *)p);
-    d = (UWord)(q - p);
-
-    if (d > 0)
-	munmap(p, d);
-
-    if (MSEG_ALIGNED_SIZE - d > 0)
-	munmap((void *)(q + length), MSEG_ALIGNED_SIZE - d);
-
-    return q;
-}
+/* #define ERTS_PRINT_ERTS_MMAP */
 
 static ERTS_INLINE void *
-mseg_create(ErtsMsegAllctr_t *ma, MemKind* mk, Uint size)
+mseg_create(ErtsMsegAllctr_t *ma, Uint flags, MemKind* mk, UWord *sizep)
 {
+#ifdef ERTS_PRINT_ERTS_MMAP
+    UWord req_size = *sizep;
+#endif
     void *seg;
-    ASSERT(size % MSEG_ALIGNED_SIZE == 0);
-
+    Uint32 mmap_flags = 0;
 #if HALFWORD_HEAP
-    if (mk == &ma->low_mem) {
-	seg = pmmap(size);
-	if ((unsigned long) seg & CHECK_POINTER_MASK) {
-	    erts_fprintf(stderr,"Pointer mask failure (0x%08lx)\n",(unsigned long) seg);
-	    return NULL;
-	}
-    } else
+    mmap_flags |= ((mk == &ma->low_mem)
+		   ? ERTS_MMAPFLG_SUPERCARRIER_ONLY
+		   : ERTS_MMAPFLG_OS_ONLY);
 #endif
-    {
-#if HAVE_MMAP
-	{
-	    seg = (void *) mmap_align(ma, (void *) 0, (size_t) size,
-				MMAP_PROT, MMAP_FLAGS, MMAP_FD, 0);
-	    if (seg == (void *) MAP_FAILED)
-		seg = NULL;
-
-	    ASSERT(MAP_IS_ALIGNED(seg) || !seg);
-	}
-#else
-# error "Missing mseg_create() implementation"
+    if (MSEG_FLG_IS_2POW(flags))
+	mmap_flags |= ERTS_MMAPFLG_SUPERALIGNED;
+
+    seg = erts_mmap(mmap_flags, sizep);
+
+#ifdef ERTS_PRINT_ERTS_MMAP
+    erts_fprintf(stderr, "%p = erts_mmap(%s, {%bpu, %bpu});\n", seg,
+		 (mmap_flags & ERTS_MMAPFLG_SUPERALIGNED) ? "sa" : "sua",
+		 req_size, *sizep);
 #endif
-    }
 
     INC_CC(ma, create);
 
@@ -414,91 +330,55 @@ mseg_create(ErtsMsegAllctr_t *ma, MemKind* mk, Uint size)
 }
 
 static ERTS_INLINE void
-mseg_destroy(ErtsMsegAllctr_t *ma, MemKind* mk, void *seg, Uint size) {
-    ERTS_DECLARE_DUMMY(int res);
-
+mseg_destroy(ErtsMsegAllctr_t *ma, Uint flags, MemKind* mk, void **seg_pp, UWord *size_p) {
+    
+    Uint32 mmap_flags = 0;
 #if HALFWORD_HEAP
-    if (mk == &ma->low_mem) {
-	res = pmunmap((void *) seg, size);
-    }
-    else
+    mmap_flags |= ((mk == &ma->low_mem)
+		   ? ERTS_MMAPFLG_SUPERCARRIER_ONLY
+		   : ERTS_MMAPFLG_OS_ONLY);
 #endif
-    {
-#ifdef HAVE_MMAP
-	res = munmap((void *) seg, size);
-#else
-# error "Missing mseg_destroy() implementation"
+    if (MSEG_FLG_IS_2POW(flags))
+	 mmap_flags |= ERTS_MMAPFLG_SUPERALIGNED;
+
+    erts_munmap(mmap_flags, seg_pp, size_p);
+#ifdef ERTS_PRINT_ERTS_MMAP
+    erts_fprintf(stderr, "erts_munmap(%s, %p, %bpu);\n",
+		 (mmap_flags & ERTS_MMAPFLG_SUPERALIGNED) ? "sa" : "sua",
+		 *seg_pp, *size_p);
 #endif
-    }
-
-    ASSERT(size % MSEG_ALIGNED_SIZE == 0);
-    ASSERT(res == 0);
-
     INC_CC(ma, destroy);
 
 }
 
-#if HAVE_MSEG_RECREATE
-#if defined(__NetBSD__)
-#define MREMAP_FLAGS  (0)
-#else
-#define MREMAP_FLAGS  (MREMAP_MAYMOVE)
-#endif
-
-
-/* mseg_recreate
- * May return *unaligned* segments as in address not aligned to MSEG_ALIGNMENT
- * it is still page aligned
- *
- * This is fine for single block carriers as long as we don't cache misaligned
- * segments (since multiblock carriers may use them)
- *
- * For multiblock carriers we *need* MSEG_ALIGNMENT but mbc's will never be
- * reallocated.
- *
- * This should probably be fixed the following way:
- * 1) Use an option to segment allocation - NEED_ALIGNMENT
- * 2) Add mremap_align which takes care of aligning a new a mremaped area
- * 3) Fix the cache to handle of aligned and unaligned segments
- */
-
 static ERTS_INLINE void *
-mseg_recreate(ErtsMsegAllctr_t *ma, MemKind* mk, void *old_seg, Uint old_size, Uint new_size)
+mseg_recreate(ErtsMsegAllctr_t *ma, Uint flags, MemKind* mk, void *old_seg, UWord old_size, UWord *sizep)
 {
+#ifdef ERTS_PRINT_ERTS_MMAP
+    UWord req_size = *sizep;	
+#endif
     void *new_seg;
-
-    ASSERT(old_size % MSEG_ALIGNED_SIZE == 0);
-    ASSERT(new_size % MSEG_ALIGNED_SIZE == 0);
-
+    Uint32 mmap_flags = 0;
 #if HALFWORD_HEAP
-    if (mk == &ma->low_mem) {
-	new_seg = (void *) pmremap((void *) old_seg,
-				   (size_t) old_size,
-				   (size_t) new_size);
-    }
-    else
-#endif
-    {
-#if HAVE_MREMAP
-#if defined(__NetBSD__)
-	new_seg = mremap(old_seg, (size_t)old_size, NULL, new_size, MREMAP_FLAGS);
-#else
-	new_seg = mremap(old_seg, (size_t)old_size, (size_t)new_size, MREMAP_FLAGS);
+    mmap_flags |= ((mk == &ma->low_mem)
+		   ? ERTS_MMAPFLG_SUPERCARRIER_ONLY
+		   : ERTS_MMAPFLG_OS_ONLY);
 #endif
-	if (new_seg == (void *) MAP_FAILED)
-	    new_seg = NULL;
-#else
-#error "Missing mseg_recreate() implementation"
-#endif
-    }
+    if (MSEG_FLG_IS_2POW(flags))
+	mmap_flags |= ERTS_MMAPFLG_SUPERALIGNED;
+
+    new_seg = erts_mremap(mmap_flags, old_seg, old_size, sizep);
 
+#ifdef ERTS_PRINT_ERTS_MMAP
+    erts_fprintf(stderr, "%p = erts_mremap(%s, %p, %bpu, {%bpu, %bpu});\n",
+		 new_seg, (mmap_flags & ERTS_MMAPFLG_SUPERALIGNED) ? "sa" : "sua",
+		 old_seg, old_size, req_size, *sizep);
+#endif
     INC_CC(ma, recreate);
 
     return new_seg;
 }
 
-#endif /* #if HAVE_MSEG_RECREATE */
-
 #ifdef DEBUG
 #define ERTS_DBG_MA_CHK_THR_ACCESS(MA)					\
 do {									\
@@ -566,14 +446,19 @@ static ERTS_INLINE int cache_bless_segment(MemKind *mk, void *seg, Uint size, Ui
 
 	return 1;
     } else if (!MSEG_FLG_IS_2POW(flags) && !erts_circleq_is_empty(&(mk->cache_unpowered_node))) {
-
+	void *destr_seg;
+	UWord destr_size;
 	/* No free slots.
 	 * Evict oldest slot from unpowered cache so we can cache an unpowered (sbc) segment  */
 
 	c = erts_circleq_tail(&(mk->cache_unpowered_node));
 	erts_circleq_remove(c);
 
-	mseg_destroy(mk->ma, mk, c->seg, c->size);
+	destr_seg = c->seg;
+	destr_size = c->size;
+	mseg_destroy(mk->ma, ERTS_MSEG_FLG_NONE, mk, &destr_seg, &destr_size);
+	ASSERT(destr_seg == c->seg);
+	ASSERT(destr_size == c->size);
 	mseg_cache_clear_node(c);
 
 	c->seg  = seg;
@@ -593,13 +478,20 @@ static ERTS_INLINE int cache_bless_segment(MemKind *mk, void *seg, Uint size, Ui
 	int i;
 
 	for( i = 0; i < CACHE_AREAS; i++) {
+	    void *destr_seg;
+	    UWord destr_size;
 	    if (erts_circleq_is_empty(&(mk->cache_powered_node[i])))
 		continue;
 
 	    c = erts_circleq_tail(&(mk->cache_powered_node[i]));
 	    erts_circleq_remove(c);
 
-	    mseg_destroy(mk->ma, mk, c->seg, c->size);
+	    destr_seg = seg;
+	    destr_size = c->size;
+	    mseg_destroy(mk->ma, ERTS_MSEG_FLG_2POW, mk, &destr_seg, &destr_size);
+	    ASSERT(destr_seg == c->seg);
+	    ASSERT(destr_size == c->size);
+
 	    mseg_cache_clear_node(c);
 
 	    c->seg  = seg;
@@ -614,9 +506,9 @@ static ERTS_INLINE int cache_bless_segment(MemKind *mk, void *seg, Uint size, Ui
     return 0;
 }
 
-static ERTS_INLINE void *cache_get_segment(MemKind *mk, Uint *size_p, Uint flags) {
+static ERTS_INLINE void *cache_get_segment(MemKind *mk, UWord *size_p, Uint flags) {
 
-    Uint size = *size_p;
+    Uint size = (UWord) *size_p;
 
     ERTS_DBG_MK_CHK_THR_ACCESS(mk);
 
@@ -653,7 +545,11 @@ static ERTS_INLINE void *cache_get_segment(MemKind *mk, Uint *size_p, Uint flags
 	    ASSERT(!(mk->cache_size < 0));
 
 	    if (csize != size) {
-		mseg_destroy(mk->ma, mk, (char *)seg + size, csize - size);
+		void *destr_seg = ((char *) seg) + size;
+		UWord destr_size = csize - size;
+		mseg_destroy(mk->ma, ERTS_MSEG_FLG_2POW, mk, &destr_seg, &destr_size);
+		*size_p = (UWord) (destr_seg - seg);
+		ASSERT(c->seg + c->size == destr_seg + destr_size);
 	    }
 
 	    return seg;
@@ -683,7 +579,7 @@ static ERTS_INLINE void *cache_get_segment(MemKind *mk, Uint *size_p, Uint flags
 		    mseg_cache_clear_node(c);
 		    erts_circleq_push_head(&(mk->cache_free), c);
 
-		    *size_p = csize;
+		    *size_p = (UWord) csize;
 
 		    return seg;
 
@@ -714,7 +610,7 @@ static ERTS_INLINE void *cache_get_segment(MemKind *mk, Uint *size_p, Uint flags
 	    ASSERT((size % GET_PAGE_SIZE) == 0);
 	    ASSERT((best->size % GET_PAGE_SIZE) == 0);
 
-	    *size_p = size;
+	    *size_p = (UWord) size;
 
 	    return seg;
 
@@ -728,7 +624,9 @@ static ERTS_INLINE void *cache_get_segment(MemKind *mk, Uint *size_p, Uint flags
  * using callbacks from aux-work in the scheduler.
  */
 
-static ERTS_INLINE Uint mseg_drop_one_memkind_cache_size(MemKind *mk, cache_t *head) {
+static ERTS_INLINE Uint mseg_drop_one_memkind_cache_size(MemKind *mk, Uint flags, cache_t *head) {
+    void *destr_seg;
+    UWord destr_size;
     cache_t *c = NULL;
 
     c = erts_circleq_tail(head);
@@ -737,7 +635,11 @@ static ERTS_INLINE Uint mseg_drop_one_memkind_cache_size(MemKind *mk, cache_t *h
     if (erts_mtrace_enabled)
 	erts_mtrace_crr_free(SEGTYPE, SEGTYPE, c->seg);
 
-    mseg_destroy(mk->ma, mk, c->seg, c->size);
+    destr_seg = c->seg;
+    destr_size = c->size;
+    mseg_destroy(mk->ma, flags, mk, &destr_seg, &destr_size);
+    ASSERT(destr_seg == c->seg);
+    ASSERT(destr_size == c->size);
     mseg_cache_clear_node(c);
     erts_circleq_push_head(&(mk->cache_free), c);
 
@@ -749,10 +651,12 @@ static ERTS_INLINE Uint mseg_drop_one_memkind_cache_size(MemKind *mk, cache_t *h
     return mk->cache_size;
 }
 
-static ERTS_INLINE Uint mseg_drop_memkind_cache_size(MemKind *mk, cache_t *head) {
+static ERTS_INLINE Uint mseg_drop_memkind_cache_size(MemKind *mk, Uint flags, cache_t *head) {
     cache_t *c = NULL;
 
     while (!erts_circleq_is_empty(head)) {
+	void *destr_seg;
+	UWord destr_size;
 
 	c = erts_circleq_tail(head);
 	erts_circleq_remove(c);
@@ -760,7 +664,11 @@ static ERTS_INLINE Uint mseg_drop_memkind_cache_size(MemKind *mk, cache_t *head)
 	if (erts_mtrace_enabled)
 	    erts_mtrace_crr_free(SEGTYPE, SEGTYPE, c->seg);
 
-	mseg_destroy(mk->ma, mk, c->seg, c->size);
+	destr_seg = c->seg;
+	destr_size = c->size;
+	mseg_destroy(mk->ma, flags, mk, &destr_seg, &destr_size);
+	ASSERT(destr_seg == c->seg);
+	ASSERT(destr_size == c->size);
 
 	mseg_cache_clear_node(c);
 	erts_circleq_push_head(&(mk->cache_free), c);
@@ -788,11 +696,11 @@ static Uint mseg_check_memkind_cache(MemKind *mk) {
 
     for (i = 0; i < CACHE_AREAS; i++) {
 	if (!erts_circleq_is_empty(&(mk->cache_powered_node[i])))
-	    return mseg_drop_one_memkind_cache_size(mk, &(mk->cache_powered_node[i]));
+	    return mseg_drop_one_memkind_cache_size(mk, ERTS_MSEG_FLG_2POW, &(mk->cache_powered_node[i]));
     }
 
     if (!erts_circleq_is_empty(&(mk->cache_unpowered_node)))
-	    return mseg_drop_one_memkind_cache_size(mk, &(mk->cache_unpowered_node));
+	return mseg_drop_one_memkind_cache_size(mk, ERTS_MSEG_FLG_NONE, &(mk->cache_unpowered_node));
 
     return 0;
 }
@@ -851,12 +759,12 @@ static void mseg_clear_memkind_cache(MemKind *mk) {
 	if (erts_circleq_is_empty(&(mk->cache_powered_node[i])))
 	    continue;
 
-	mseg_drop_memkind_cache_size(mk, &(mk->cache_powered_node[i]));
+	mseg_drop_memkind_cache_size(mk, ERTS_MSEG_FLG_2POW, &(mk->cache_powered_node[i]));
 	ASSERT(erts_circleq_is_empty(&(mk->cache_powered_node[i])));
     }
     /* drop varied caches */
     if (!erts_circleq_is_empty(&(mk->cache_unpowered_node)))
-	mseg_drop_memkind_cache_size(mk, &(mk->cache_unpowered_node));
+	mseg_drop_memkind_cache_size(mk, ERTS_MSEG_FLG_NONE, &(mk->cache_unpowered_node));
 
     ASSERT(erts_circleq_is_empty(&(mk->cache_unpowered_node)));
     ASSERT(mk->cache_size == 0);
@@ -896,36 +804,33 @@ static ERTS_INLINE MemKind* memkind(ErtsMsegAllctr_t *ma,
 }
 
 static void *
-mseg_alloc(ErtsMsegAllctr_t *ma, ErtsAlcType_t atype, Uint *size_p,
+mseg_alloc(ErtsMsegAllctr_t *ma, ErtsAlcType_t atype, UWord *size_p,
 	   Uint flags, const ErtsMsegOpt_t *opt)
 {
-    Uint size;
+    UWord size;
     void *seg;
     MemKind* mk = memkind(ma, opt);
 
     INC_CC(ma, alloc);
 
-    /* Carrier align */
-    size = ALIGNED_CEILING(*size_p);
-
-    /* Cache optim (if applicable) */
-    if (MSEG_FLG_IS_2POW(flags) && !IS_2POW(size))
+    if (!MSEG_FLG_IS_2POW(flags) && !IS_2POW(size))
+	size = ERTS_PAGEALIGNED_CEILING(*size_p);
+    else {
+	size = ALIGNED_CEILING(*size_p);
+	/* Cache optim (if applicable) */
 	size = ceil_2pow(size);
+    }
 
-#if CAN_PARTLY_DESTROY
-    if (size < ma->min_seg_size)	
-	ma->min_seg_size = size;
-#endif
-    
     if (opt->cache && mk->cache_size > 0 && (seg = cache_get_segment(mk, &size, flags)) != NULL)
 	goto done;
 
-    if ((seg = mseg_create(ma, mk, size)) == NULL)
-	size = 0;
+    seg = mseg_create(ma, flags, mk, &size);
 
+    if (!seg)
+	*size_p = 0;
+    else {
 done:
-    *size_p = size;
-    if (seg) {
+	*size_p = size;
 	if (erts_mtrace_enabled)
 	    erts_mtrace_crr_alloc(seg, atype, ERTS_MTRACE_SEGMENT_ID, size);
 
@@ -937,14 +842,16 @@ done:
 
 
 static void
-mseg_dealloc(ErtsMsegAllctr_t *ma, ErtsAlcType_t atype, void *seg, Uint size,
+mseg_dealloc(ErtsMsegAllctr_t *ma, ErtsAlcType_t atype, void *seg, UWord size,
 	     Uint flags, const ErtsMsegOpt_t *opt)
 {
+    void *destr_seg;
+    UWord destr_size;
     MemKind* mk = memkind(ma, opt);
 
     ERTS_MSEG_DEALLOC_STAT(mk,size);
 
-    if (opt->cache && cache_bless_segment(mk, seg, size, flags)) {
+    if (opt->cache && cache_bless_segment(mk, seg, (Uint) size, flags)) {
 	schedule_cache_check(ma);
 	goto done;
     }
@@ -952,7 +859,11 @@ mseg_dealloc(ErtsMsegAllctr_t *ma, ErtsAlcType_t atype, void *seg, Uint size,
     if (erts_mtrace_enabled)
 	erts_mtrace_crr_free(atype, SEGTYPE, seg);
 
-    mseg_destroy(ma, mk, seg, size);
+    destr_seg = seg;
+    destr_size = size;
+    mseg_destroy(ma, flags, mk, &destr_seg, &destr_size);
+    ASSERT(destr_seg == seg);
+    ASSERT(destr_size == size);
 
 done:
 
@@ -961,11 +872,11 @@ done:
 
 static void *
 mseg_realloc(ErtsMsegAllctr_t *ma, ErtsAlcType_t atype, void *seg,
-	     Uint old_size, Uint *new_size_p, Uint flags, const ErtsMsegOpt_t *opt)
+	     UWord old_size, UWord *new_size_p, Uint flags, const ErtsMsegOpt_t *opt)
 {
     MemKind* mk;
     void *new_seg;
-    Uint new_size;
+    UWord new_size;
 
     /* Just allocate a new segment if we didn't have one before */
     if (!seg || !old_size) {
@@ -985,90 +896,46 @@ mseg_realloc(ErtsMsegAllctr_t *ma, ErtsAlcType_t atype, void *seg,
     mk = memkind(ma, opt);
     new_seg = seg;
 
-    /* Carrier align */
-    new_size = ALIGNED_CEILING(*new_size_p);
 
-    /* Cache optim (if applicable) */
-    if (MSEG_FLG_IS_2POW(flags) && !IS_2POW(new_size))
+    if (!MSEG_FLG_IS_2POW(flags))
+	new_size = ERTS_PAGEALIGNED_CEILING(*new_size_p);
+    else {
+	new_size = ALIGNED_CEILING(*new_size_p);
+	/* Cache optim (if applicable) */
 	new_size = ceil_2pow(new_size);
+    }
 
-    if (new_size == old_size)
-	;
-    else if (new_size < old_size) {
-	Uint shrink_sz = old_size - new_size;
-
-#if CAN_PARTLY_DESTROY
-	if (new_size < ma->min_seg_size)	
-	    ma->min_seg_size = new_size;
-#endif
-	/* +M<S>rsbcst <ratio> */
-	if (shrink_sz < opt->abs_shrink_th
-	    && 100*shrink_sz < opt->rel_shrink_th*old_size) {
-	    new_size = old_size;
+    if (new_size > old_size) {
+	if (opt->preserv) {
+	    new_seg = mseg_recreate(ma, flags, mk, (void *) seg, old_size, &new_size);
+	    if (!new_seg)
+		new_size = old_size;
 	}
 	else {
-
-#if CAN_PARTLY_DESTROY
-
-	    if (erts_mtrace_enabled)
-		erts_mtrace_crr_realloc(new_seg, atype, SEGTYPE, seg, new_size);
-
-	    mseg_destroy(ma, mk, ((char *) seg) + new_size, shrink_sz);
-
-#elif HAVE_MSEG_RECREATE
-	    goto do_recreate;
-#else
+	    mseg_dealloc(ma, atype, seg, old_size, flags, opt);
 	    new_seg = mseg_alloc(ma, atype, &new_size, flags, opt);
-
-	    ASSERT(MAP_IS_ALIGNED(new_seg) || !new_seg);
-
 	    if (!new_seg)
-		new_size = old_size;
-	    else {
-		sys_memcpy(((char *) new_seg),
-			   ((char *) seg),
-			   MIN(new_size, old_size));
-		mseg_dealloc(ma, atype, seg, old_size, flags, opt);
-	    }
-#endif
+		new_size = 0;
 	}
     }
-    else {
+    else if (new_size < old_size) {
+	UWord shrink_sz = old_size - new_size;
 
-	if (!opt->preserv) {
-	    mseg_dealloc(ma, atype, seg, old_size, flags, opt);
-	    new_seg = mseg_alloc(ma, atype, &new_size, flags, opt);
-	    ASSERT(MAP_IS_ALIGNED(new_seg) || !new_seg);
+	/* +M<S>rsbcst <ratio> */
+	if (shrink_sz < opt->abs_shrink_th
+	    && 100*shrink_sz < opt->rel_shrink_th*old_size) {
+	    new_size = old_size;
 	}
 	else {
-#if HAVE_MSEG_RECREATE
-#if !CAN_PARTLY_DESTROY
-	do_recreate:
-#endif
-	    new_seg = mseg_recreate(ma, mk, (void *) seg, old_size, new_size);
-	    /* ASSERT(MAP_IS_ALIGNED(new_seg) || !new_seg);
-	     * will not always be aligned and it ok for now
-	     */
-
-	    if (erts_mtrace_enabled)
-		erts_mtrace_crr_realloc(new_seg, atype, SEGTYPE, seg, new_size);
+	    new_seg = mseg_recreate(ma, flags, mk, (void *) seg, old_size, &new_size);
 	    if (!new_seg)
 		new_size = old_size;
-#else
-	    new_seg = mseg_alloc(ma, atype, &new_size, flags, opt);
-
-	    ASSERT(MAP_IS_ALIGNED(new_seg) || !new_seg);
-
-	    if (!new_seg)
-		new_size = old_size;
-	    else {
-		sys_memcpy(((char *) new_seg), ((char *) seg), MIN(new_size, old_size));
-		mseg_dealloc(ma, atype, seg, old_size, flags, opt);
-	    }
-#endif
 	}
     }
 
+    if (erts_mtrace_enabled)
+	erts_mtrace_crr_realloc(new_seg, atype, SEGTYPE, seg, new_size);
+
     INC_CC(ma, realloc);
 
     ASSERT(!MSEG_FLG_IS_2POW(flags) || IS_2POW(new_size));
@@ -1106,9 +973,7 @@ static struct {
     Eterm mseg_create;
     Eterm mseg_create_resize;
     Eterm mseg_destroy;
-#if HAVE_MSEG_RECREATE
     Eterm mseg_recreate;
-#endif
     Eterm mseg_clear_cache;
     Eterm mseg_check_cache;
 
@@ -1163,9 +1028,7 @@ init_atoms(ErtsMsegAllctr_t *ma)
 	AM_INIT(mseg_create);
 	AM_INIT(mseg_create_resize);
 	AM_INIT(mseg_destroy);
-#if HAVE_MSEG_RECREATE
 	AM_INIT(mseg_recreate);
-#endif
 	AM_INIT(mseg_clear_cache);
 	AM_INIT(mseg_check_cache);
 
@@ -1293,9 +1156,7 @@ info_calls(ErtsMsegAllctr_t *ma, int *print_to_p, void *print_to_arg, Uint **hpp
 	PRINT_CC(to, arg, create);
 	PRINT_CC(to, arg, create_resize);
 	PRINT_CC(to, arg, destroy);
-#if HAVE_MSEG_RECREATE
 	PRINT_CC(to, arg, recreate);
-#endif
 	PRINT_CC(to, arg, clear_cache);
 	PRINT_CC(to, arg, check_cache);
 
@@ -1316,12 +1177,10 @@ info_calls(ErtsMsegAllctr_t *ma, int *print_to_p, void *print_to_arg, Uint **hpp
 		 bld_unstable_uint(hpp, szp, ma->calls.clear_cache.giga_no),
 		 bld_unstable_uint(hpp, szp, ma->calls.clear_cache.no));
 
-#if HAVE_MSEG_RECREATE
 	add_3tup(hpp, szp, &res,
 		 am.mseg_recreate,
 		 bld_unstable_uint(hpp, szp, ma->calls.recreate.giga_no),
 		 bld_unstable_uint(hpp, szp, ma->calls.recreate.no));
-#endif
 	add_3tup(hpp, szp, &res,
 		 am.mseg_destroy,
 		 bld_unstable_uint(hpp, szp, ma->calls.destroy.giga_no),
@@ -1521,7 +1380,7 @@ erts_mseg_info(int ix,
 }
 
 void *
-erts_mseg_alloc_opt(ErtsAlcType_t atype, Uint *size_p, Uint flags, const ErtsMsegOpt_t *opt)
+erts_mseg_alloc_opt(ErtsAlcType_t atype, UWord *size_p, Uint flags, const ErtsMsegOpt_t *opt)
 {
     ErtsMsegAllctr_t *ma = ERTS_MSEG_ALLCTR_OPT(opt);
     void *seg;
@@ -1533,14 +1392,14 @@ erts_mseg_alloc_opt(ErtsAlcType_t atype, Uint *size_p, Uint flags, const ErtsMse
 }
 
 void *
-erts_mseg_alloc(ErtsAlcType_t atype, Uint *size_p, Uint flags)
+erts_mseg_alloc(ErtsAlcType_t atype, UWord *size_p, Uint flags)
 {
     return erts_mseg_alloc_opt(atype, size_p, flags, &erts_mseg_default_opt);
 }
 
 void
 erts_mseg_dealloc_opt(ErtsAlcType_t atype, void *seg,
-		      Uint size, Uint flags, const ErtsMsegOpt_t *opt)
+		      UWord size, Uint flags, const ErtsMsegOpt_t *opt)
 {
     ErtsMsegAllctr_t *ma = ERTS_MSEG_ALLCTR_OPT(opt);
     ERTS_MSEG_LOCK(ma);
@@ -1550,14 +1409,14 @@ erts_mseg_dealloc_opt(ErtsAlcType_t atype, void *seg,
 }
 
 void
-erts_mseg_dealloc(ErtsAlcType_t atype, void *seg, Uint size, Uint flags)
+erts_mseg_dealloc(ErtsAlcType_t atype, void *seg, UWord size, Uint flags)
 {
     erts_mseg_dealloc_opt(atype, seg, size, flags, &erts_mseg_default_opt);
 }
 
 void *
 erts_mseg_realloc_opt(ErtsAlcType_t atype, void *seg,
-		      Uint old_size, Uint *new_size_p,
+		      UWord old_size, UWord *new_size_p,
 		      Uint flags,
 		      const ErtsMsegOpt_t *opt)
 {
@@ -1572,7 +1431,7 @@ erts_mseg_realloc_opt(ErtsAlcType_t atype, void *seg,
 
 void *
 erts_mseg_realloc(ErtsAlcType_t atype, void *seg,
-		  Uint old_size, Uint *new_size_p, Uint flags)
+		  UWord old_size, UWord *new_size_p, Uint flags)
 {
     return erts_mseg_realloc_opt(atype, seg, old_size, new_size_p,
 				 flags, &erts_mseg_default_opt);
@@ -1662,19 +1521,16 @@ erts_mseg_init(ErtsMsegInit_t *init)
 
     erts_mtx_init(&init_atoms_mutex, "mseg_init_atoms");
 
-#if HAVE_MMAP && !defined(MAP_ANON)
-    mmap_fd = open("/dev/zero", O_RDWR);
-    if (mmap_fd < 0)
-	erl_exit(ERTS_ABORT_EXIT, "erts_mseg: unable to open /dev/zero\n");
+#if HALFWORD_HEAP
+    if (sizeof(void *) != 8)
+	erl_exit(-1,"Halfword emulator cannot be run in 32bit mode");
+
+    init->mmap.virtual_range.start = (char *) sbrk(0);
+    init->mmap.virtual_range.end = (char *) 0x100000000UL;
+    init->mmap.sco = 0;
 #endif
 
-#if HAVE_MMAP
-# if HALFWORD_HEAP
-    initialize_pmmap();
-# else
     erts_mmap_init(&init->mmap);
-# endif
-#endif
 
     if (!IS_2POW(GET_PAGE_SIZE))
 	erl_exit(ERTS_ABORT_EXIT, "erts_mseg: Unexpected page_size %beu\n", GET_PAGE_SIZE);
@@ -1716,10 +1572,6 @@ erts_mseg_init(ErtsMsegInit_t *init)
 #endif
 
 	sys_memzero((void *) &ma->calls, sizeof(ErtsMsegCalls));
-
-#if CAN_PARTLY_DESTROY
-	ma->min_seg_size = ~((Uint) 0);
-#endif
     }
 }
 
@@ -1761,7 +1613,7 @@ erts_mseg_test(UWord op, UWord a1, UWord a2, UWord a3)
     case 0x400: /* Have erts_mseg */
 	return (UWord) 1;
     case 0x401:
-	return (UWord) erts_mseg_alloc(ERTS_ALC_A_INVALID, (Uint *) a1, (Uint) 0);
+	return (UWord) erts_mseg_alloc(ERTS_ALC_A_INVALID, (UWord *) a1, (Uint) 0);
     case 0x402:
 	erts_mseg_dealloc(ERTS_ALC_A_INVALID, (void *) a1, (Uint) a2, (Uint) 0);
 	return (UWord) 0;
@@ -1769,7 +1621,7 @@ erts_mseg_test(UWord op, UWord a1, UWord a2, UWord a3)
 	return (UWord) erts_mseg_realloc(ERTS_ALC_A_INVALID,
 						 (void *) a1,
 						 (Uint) a2,
-						 (Uint *) a3,
+						 (UWord *) a3,
 						 (Uint) 0);
     case 0x404:
 	erts_mseg_clear_cache();
@@ -1792,405 +1644,3 @@ erts_mseg_test(UWord op, UWord a1, UWord a2, UWord a3)
     }
 
 }
-
-
-#if HALFWORD_HEAP
-/*
- * Very simple page oriented mmap replacer. Works in the lower
- * 32 bit address range of a 64bit program.
- * Implements anonymous mmap mremap and munmap with address order first fit.
- * The free list is expected to be very short...
- * To be used for compressed pointers in Erlang halfword emulator
- * implementation. The MacOS X version is more of a toy, it's not really
- * for production as the halfword erlang VM relies on Linux specific memory
- * mapping tricks.
- */
-
-/* #define HARDDEBUG 1 */
-
-#ifdef HARDDEBUG
-static void dump_freelist(void)
-{
-    FreeBlock *p = first;
-
-    while (p) {
-	fprintf(stderr, "p = %p\r\np->num = %ld\r\np->next = %p\r\n\r\n",
-	       (void *) p, (unsigned long) p->num, (void *) p->next);
-	p = p->next;
-    }
-}
-
-#define HARDDEBUG_HW_INCOMPLETE_ALIGNMENT(PTR, SZ)            \
-    fprintf(stderr,"Mapping of address %p with size %ld "     \
-	    "does not map complete pages (%s:%d)\r\n",        \
-	    (void *) (PTR), (unsigned long) (SZ),__FILE__, __LINE__)
-
-#define HARDDEBUG_HW_UNALIGNED_ALIGNMENT(PTR, SZ)             \
-    fprintf(stderr,"Mapping of address %p with size %ld "     \
-	    "is not page aligned (%s:%d)\r\n",                \
-	    (void *) (PTR), (unsigned long) (SZ),__FILE__, __LINE__)
-
-#define HARDDEBUG_MAP_FAILED(PTR, SZ) \
-    fprintf(stderr, "Could not actually map memory "          \
-	    "at address %p with size %ld (%s:%d) ..\r\n",     \
-	    (void *) (PTR), (unsigned long) (SZ),__FILE__, __LINE__)
-#else
-#define HARDDEBUG_HW_INCOMPLETE_ALIGNMENT(PTR, SZ) do{}while(0)
-#define HARDDEBUG_HW_UNALIGNED_ALIGNMENT(PTR, SZ)  do{}while(0)
-#define HARDDEBUG_MAP_FAILED(PTR, SZ)              do{}while(0)
-#endif
-
-
-#ifdef __APPLE__
-#define MAP_ANONYMOUS MAP_ANON
-#endif
-
-#define INIT_LOCK() do {erts_mtx_init(&pmmap_mutex, "pmmap");} while(0)
-
-#define TAKE_LOCK()  do {erts_mtx_lock(&pmmap_mutex);} while(0)
-
-#define RELEASE_LOCK() do {erts_mtx_unlock(&pmmap_mutex);} while(0)
-
-static erts_mtx_t pmmap_mutex; /* Also needed when !USE_THREADS */
-
-typedef struct _free_block {
-    unsigned long num; /*pages*/
-    struct _free_block *next;
-} FreeBlock;
-
-/* Protect with lock */
-static FreeBlock *first;
-
-static void *do_map(void *ptr, size_t sz)
-{
-    void *res;
-
-    if (ALIGNED_CEILING(sz) != sz) {
-	HARDDEBUG_HW_INCOMPLETE_ALIGNMENT(ptr, sz);
-	return NULL;
-    }
-
-    if (((unsigned long) ptr) % MSEG_ALIGNED_SIZE) {
-	HARDDEBUG_HW_UNALIGNED_ALIGNMENT(ptr, sz);
-	return NULL;
-    }
-
-#if HAVE_MMAP
-    res = mmap(ptr, sz,
-	       PROT_READ | PROT_WRITE, MAP_PRIVATE |
-	       MAP_ANONYMOUS | MAP_FIXED,
-	       -1 , 0);
-#else
-#  error "Missing mmap support"
-#endif
-
-    if (res == MAP_FAILED) {
-	HARDDEBUG_MAP_FAILED(ptr, sz);
-	return NULL;
-    }
-
-    return res;
-}
-
-static int do_unmap(void *ptr, size_t sz)
-{
-    void *res;
-
-    if (ALIGNED_CEILING(sz) != sz) {
-	HARDDEBUG_HW_INCOMPLETE_ALIGNMENT(ptr, sz);
-	return 1;
-    }
-
-    if (((unsigned long) ptr) % MSEG_ALIGNED_SIZE) {
-	HARDDEBUG_HW_UNALIGNED_ALIGNMENT(ptr, sz);
-	return 1;
-    }
-
-    res = mmap(ptr, sz,
-	       PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_NORESERVE | MAP_FIXED,
-	       -1 , 0);
-
-    if (res == MAP_FAILED) {
-	HARDDEBUG_MAP_FAILED(ptr, sz);
-	return 1;
-    }
-
-    return 0;
-}
-
-#ifdef __APPLE__
-/*
- * The first 4 gig's are protected on Macos X for 64bit processes :(
- * The range 0x1000000000 - 0x10FFFFFFFF is selected as an arbitrary
- * value of a normally unused range... Real MMAP's will avoid
- * it and all 32bit compressed pointers can be in that range...
- * More expensive than on Linux where expansion of compressed
- * poiters involves no masking (as they are in the first 4 gig's).
- * It's also very uncertain if the MAP_NORESERVE flag really has
- * any effect in MacOS X. Swap space may always be allocated...
- */
-#define SET_RANGE_MIN() /* nothing */
-#define RANGE_MIN 0x1000000000UL
-#define RANGE_MAX 0x1100000000UL
-#define RANGE_MASK (RANGE_MIN)
-#define EXTRA_MAP_FLAGS (MAP_FIXED)
-#else
-static size_t range_min;
-#define SET_RANGE_MIN() do { range_min = (size_t) sbrk(0); } while (0)
-#define RANGE_MIN range_min
-#define RANGE_MAX 0x100000000UL
-#define RANGE_MASK 0UL
-#define EXTRA_MAP_FLAGS (0)
-#endif
-
-static int initialize_pmmap(void)
-{
-    char *p,*q,*rptr;
-    size_t rsz;
-    FreeBlock *initial;
-
-    SET_RANGE_MIN();
-    if (sizeof(void *) != 8) {
-	erl_exit(1,"Halfword emulator cannot be run in 32bit mode");
-    }
-
-    p = (char *) RANGE_MIN;
-    q = (char *) RANGE_MAX;
-
-    rsz = ALIGNED_FLOOR(q - p);
-
-    rptr = mmap_align(NULL, (void *) p, rsz,
-		PROT_NONE, MAP_PRIVATE | MAP_ANONYMOUS |
-		MAP_NORESERVE | EXTRA_MAP_FLAGS,
-		-1 , 0);
-#ifdef HARDDEBUG
-    printf("p=%p, rsz = %ld, pages = %ld, got range = %p -> %p\r\n",
-	   p, (unsigned long) rsz, (unsigned long) (rsz / MSEG_ALIGNED_SIZE),
-	   (void *) rptr, (void*)(rptr + rsz));
-#endif
-    if ((UWord)(rptr + rsz) > RANGE_MAX) {
-	size_t rsz_trunc = RANGE_MAX - (UWord)rptr;
-#ifdef HARDDEBUG
-	printf("Reducing mmap'ed memory from %lu to %lu Mb, reduced range = %p -> %p\r\n",
-		rsz/(1024*1024), rsz_trunc/(1024*1024), rptr, rptr+rsz_trunc);
-#endif
-	munmap((void*)RANGE_MAX, rsz - rsz_trunc);
-	rsz = rsz_trunc;
-    }
-    if (!do_map(rptr, MSEG_ALIGNED_SIZE)) {
-	erl_exit(1,"Could not actually mmap first page for halfword emulator...\n");
-    }
-    initial = (FreeBlock *) rptr;
-    initial->num = (rsz / MSEG_ALIGNED_SIZE);
-    initial->next = NULL;
-    first = initial;
-    INIT_LOCK();
-    return 0;
-}
-
-static void *pmmap(size_t size)
-{
-    size_t real_size = ALIGNED_CEILING(size);
-    size_t num_pages = real_size / MSEG_ALIGNED_SIZE;
-    FreeBlock **block;
-    FreeBlock *tail;
-    FreeBlock *res;
-
-    TAKE_LOCK();
-
-    for (block = &first;
-	 *block != NULL && (*block)->num < num_pages;
-	 block = &((*block)->next))
-	;
-    if (!(*block)) {
-	RELEASE_LOCK();
-	return NULL;
-    }
-    if ((*block)->num == num_pages) {
-	/* nice, perfect fit */
-	res    = *block;
-	*block = (*block)->next;
-    } else {
-	tail = (FreeBlock *) (((char *) ((void *) (*block))) + real_size);
-	if (!do_map(tail, MSEG_ALIGNED_SIZE)) {
-	    HARDDEBUG_MAP_FAILED(tail, MSEG_ALIGNED_SIZE);
-	    RELEASE_LOCK();
-	    return NULL;
-	}
-	tail->num  = (*block)->num - num_pages;
-	tail->next = (*block)->next;
-	res = *block;
-	*block = tail;
-    }
-
-    RELEASE_LOCK();
-
-    if (!do_map(res, real_size)) {
-	HARDDEBUG_MAP_FAILED(res, real_size);
-	return NULL;
-    }
-
-    return (void *) res;
-}
-
-static int pmunmap(void *p, size_t size)
-{
-    size_t real_size = ALIGNED_CEILING(size);
-    size_t num_pages = real_size / MSEG_ALIGNED_SIZE;
-
-    FreeBlock *block;
-    FreeBlock *last;
-    FreeBlock *nb = (FreeBlock *) p;
-
-    ASSERT(((unsigned long)p & CHECK_POINTER_MASK)==0);
-
-    if (real_size > MSEG_ALIGNED_SIZE) {
-	if (do_unmap(((char *) p) + MSEG_ALIGNED_SIZE, real_size - MSEG_ALIGNED_SIZE)) {
-	    return 1;
-	}
-    }
-
-    TAKE_LOCK();
-
-    last = NULL;
-    block = first;
-    while(block != NULL && ((void *) block) < p) {
-	last = block;
-	block = block->next;
-    }
-
-    if (block != NULL &&
-	((void *) block) == ((void *) (((char *) p) + real_size))) {
-	/* Merge new free block with following */
-	nb->num = block->num + num_pages;
-	nb->next = block->next;
-	if (do_unmap(block, MSEG_ALIGNED_SIZE)) {
-	    RELEASE_LOCK();
-	    return 1;
-	}
-    } else {
-	/* just link in */
-	nb->num = num_pages;
-	nb->next = block;
-    }
-    if (last != NULL) {
-	if (p == ((void *) (((char *) last) + (last->num * MSEG_ALIGNED_SIZE)))) {
-	    /* Merge with previous */
-	    last->num += nb->num;
-	    last->next = nb->next;
-	    if (do_unmap(nb, MSEG_ALIGNED_SIZE)) {
-		RELEASE_LOCK();
-		return 1;
-	    }
-	} else {
-	    last->next = nb;
-	}
-    } else {
-	first = nb;
-    }
-    RELEASE_LOCK();
-    return 0;
-}
-
-static void *pmremap(void *old_address, size_t old_size,
-	      size_t new_size)
-{
-    size_t new_real_size = ALIGNED_CEILING(new_size);
-    size_t new_num_pages = new_real_size / MSEG_ALIGNED_SIZE;
-    size_t old_real_size = ALIGNED_CEILING(old_size);
-    size_t old_num_pages = old_real_size / MSEG_ALIGNED_SIZE;
-    if (new_num_pages == old_num_pages) {
-	return old_address;
-    } else if (new_num_pages < old_num_pages) { /* Shrink */
-	size_t nfb_pages = old_num_pages - new_num_pages;
-	size_t nfb_real_size = old_real_size - new_real_size;
-	void *vnfb = (void *) (((char *)old_address) + new_real_size);
-	FreeBlock *nfb = (FreeBlock *) vnfb;
-	FreeBlock **block;
-	TAKE_LOCK();
-	for (block = &first;
-	     *block != NULL && (*block) < nfb;
-	     block = &((*block)->next))
-	;
-	if (!(*block) ||
-	    (*block) > ((FreeBlock *)(((char *) vnfb) + nfb_real_size))) {
-	    /* Normal link in */
-	    if (nfb_pages > 1) {
-		if (do_unmap((void *)(((char *) vnfb) + MSEG_ALIGNED_SIZE),
-			     (nfb_pages - 1)*MSEG_ALIGNED_SIZE)) {
-		    return NULL;
-		}
-	    }
-	    nfb->next = (*block);
-	    nfb->num = nfb_pages;
-	    (*block) = nfb;
-	} else { /* block merge */
-	    nfb->next = (*block)->next;
-	    nfb->num = nfb_pages + (*block)->num;
-	    /* unmap also the first page of the next freeblock */
-	    (*block) = nfb;
-	    if (do_unmap((void *)(((char *) vnfb) + MSEG_ALIGNED_SIZE),
-			 nfb_pages*MSEG_ALIGNED_SIZE)) {
-		return NULL;
-	    }
-	}
-	RELEASE_LOCK();
-	return old_address;
-    } else { /* Enlarge */
-	FreeBlock **block;
-	void *old_end = (void *) (((char *)old_address) + old_real_size);
-	TAKE_LOCK();
-	for (block = &first;
-	     *block != NULL && (*block) < (FreeBlock *) old_address;
-	     block = &((*block)->next))
-	    ;
-	if ((*block) == NULL || old_end > ((void *) RANGE_MAX) ||
-	    (*block) != old_end ||
-	    (*block)->num < (new_num_pages - old_num_pages)) {
-	    /* cannot extend */
-	    void *result;
-	    RELEASE_LOCK();
-	    result = pmmap(new_size);
-	    if (result == NULL) {
-		return NULL;
-	    }
-	    memcpy(result,old_address,old_size);
-	    if (pmunmap(old_address,old_size)) {
-		/* Oups... */
-		pmunmap(result,new_size);
-		return NULL;
-	    }
-	    return result;
-	} else { /* extend */
-	    size_t remaining_pages = (*block)->num -
-		(new_num_pages - old_num_pages);
-	    if (!remaining_pages) {
-		void *p = (void *) (((char *) (*block)) + MSEG_ALIGNED_SIZE);
-		void *n = (*block)->next;
-		size_t x = ((*block)->num - 1) * MSEG_ALIGNED_SIZE;
-		if (x > 0) {
-		    if (do_map(p,x) == NULL) {
-			RELEASE_LOCK();
-			return NULL;
-		    }
-		}
-		(*block) = n;
-	    } else {
-		FreeBlock *nfb = (FreeBlock *) ((void *)
-						(((char *) old_address) +
-						 new_real_size));
-		void *p = (void *) (((char *) (*block)) + MSEG_ALIGNED_SIZE);
-		if (do_map(p,new_real_size - old_real_size) == NULL) {
-		    RELEASE_LOCK();
-		    return NULL;
-		}
-		nfb->num = remaining_pages;
-		nfb->next = (*block)->next;
-		(*block) = nfb;
-	    }
-	    RELEASE_LOCK();
-	    return old_address;
-	}
-    }
-}
-#endif /* HALFWORD_HEAP */
diff --git a/erts/emulator/sys/common/erl_mseg.h b/erts/emulator/sys/common/erl_mseg.h
index 7454e5c473..2284b3f8f1 100644
--- a/erts/emulator/sys/common/erl_mseg.h
+++ b/erts/emulator/sys/common/erl_mseg.h
@@ -24,14 +24,14 @@
 #include "erl_alloc_types.h"
 #include "erl_mmap.h"
 
-#ifndef HAVE_MMAP
-#  define HAVE_MMAP 0
-#endif
-#ifndef HAVE_MREMAP
-#  define HAVE_MREMAP 0
-#endif
-
-#if HAVE_MMAP
+/*
+ * We currently only enable mseg_alloc if we got
+ * a genuine mmap()/munmap() primitive. It is possible
+ * to utilize erts_mmap() withiout a mmap support but
+ * alloc_util needs to be prepared before we can do
+ * that.
+ */
+#ifdef ERTS_HAVE_GENUINE_OS_MMAP
 #  define HAVE_ERTS_MSEG 1
 #  define ERTS_HAVE_MSEG_SUPER_ALIGNED 1
 #else
@@ -40,8 +40,7 @@
 #endif
 
 #if ERTS_HAVE_MSEG_SUPER_ALIGNED
-#  define MSEG_ALIGN_BITS (18)
-   /* Affects hard limits for sbct and lmbcs documented in erts_alloc.xml */
+#  define MSEG_ALIGN_BITS ERTS_MMAP_SUPERALIGNED_BITS
 #else
 /* If we don't use super aligned multiblock carriers
  * we will mmap with page size alignment (and thus use corresponding
@@ -77,7 +76,8 @@ typedef struct {
     4*1024*1024,	/* amcbf: Absolute max cache bad fit	*/	\
     20,			/* rmcbf: Relative max cache bad fit	*/	\
     10,			/* mcs:   Max cache size		*/	\
-    1000		/* cci:   Cache check interval		*/	\
+    1000,		/* cci:   Cache check interval		*/	\
+    ERTS_MMAP_INIT_DEFAULT_INITER					\
 }
 
 typedef struct {
@@ -93,12 +93,12 @@ typedef struct {
 
 extern const ErtsMsegOpt_t erts_mseg_default_opt;
 
-void *erts_mseg_alloc(ErtsAlcType_t, Uint *, Uint);
-void *erts_mseg_alloc_opt(ErtsAlcType_t, Uint *, Uint, const ErtsMsegOpt_t *);
-void  erts_mseg_dealloc(ErtsAlcType_t, void *, Uint, Uint);
-void  erts_mseg_dealloc_opt(ErtsAlcType_t, void *, Uint, Uint, const ErtsMsegOpt_t *);
-void *erts_mseg_realloc(ErtsAlcType_t, void *, Uint, Uint *, Uint);
-void *erts_mseg_realloc_opt(ErtsAlcType_t, void *, Uint, Uint *, Uint, const ErtsMsegOpt_t *);
+void *erts_mseg_alloc(ErtsAlcType_t, UWord *, Uint);
+void *erts_mseg_alloc_opt(ErtsAlcType_t, UWord *, Uint, const ErtsMsegOpt_t *);
+void  erts_mseg_dealloc(ErtsAlcType_t, void *, UWord, Uint);
+void  erts_mseg_dealloc_opt(ErtsAlcType_t, void *, UWord, Uint, const ErtsMsegOpt_t *);
+void *erts_mseg_realloc(ErtsAlcType_t, void *, UWord, UWord *, Uint);
+void *erts_mseg_realloc_opt(ErtsAlcType_t, void *, UWord, UWord *, Uint, const ErtsMsegOpt_t *);
 void  erts_mseg_clear_cache(void);
 void  erts_mseg_cache_check(void);
 Uint  erts_mseg_no( const ErtsMsegOpt_t *);